import os

from gitea import Gitea, User, Organization, Team, Repository, version
from gitea import NotFoundException, AlreadyExistsException

assert version >= '0.4.0'


# Testing a localhost instance for API-functionality.
#


# testing includes:
# - reading in token
# - creation of organization
# - creation of repository
# - creation of team
# - creation of user
# - assigning team to repository
# - assigning user to team
# - deleting created user
# - deleting repository
# - deleting team
# - deleting organization


def expect_not_exist(fn, expect) -> bool:
    try:
        fn()
        return False
    except expect:
        return True


gitea = None

# put a ".token" file into your directory containg only the token for gitea
try:
    gitea = Gitea("http://localhost:3000", open(".token", "r").read().strip())
    print("Gitea Version: " + gitea.get_version())
    print("API-Token belongs to user: " + gitea.get_user().username)
except:
    assert (
        False
    ), "Gitea could not load. \
            - Instance running at http://localhost:3000 \
            - Token at .token   \
                ?"


def test_token():
    assert gitea.get_user().username == "test", "Token user not 'test'."


def test_version():
    assert gitea.get_version() == "1.8.0-rc2", "Version changed. Updated?"


def test_before_user():
    # This should not work currently
    assert expect_not_exist(
        lambda: User(gitea, "test-user"), (NotFoundException)
    ), "User test-user should not exist"


def test_before_org():
    assert expect_not_exist(
        lambda: Organization(gitea, "test-org"), (NotFoundException)
    ), "Organization test-org should not exist"


def test_before_repo():
    assert expect_not_exist(
        lambda: Repository(gitea, User(gitea, "test-user"), "test-repo"),
        (NotFoundException),
    ), "Repository test-repo should not exist"


def test_before_team():
    assert expect_not_exist(
        lambda: Team(gitea, Organization(gitea, "test-org"), "test-team"),
        (NotFoundException),
    ), "Team test-team should not exist"


def test_create_user():
    user = gitea.create_user('test-user', 'testmail@example.org', 'pw1234')
    user.update_mail()
    assert user.username == 'test-user'
    assert user.login == 'test-user'
    assert user.email == 'testmail@example.org'
    assert not user.is_admin


def test_create_org():
    user = gitea.get_user()
    org = gitea.create_org(user, 'test-org', 'some-desc', 'loc')
    assert org.get_members() == [user]
    assert org.description == 'some-desc'
    assert org.username == 'test-org'
    assert org.location == 'loc'
    assert not org.website
    assert not org.full_name


def test_create_repo():
    org = Organization(gitea, 'test-org')
    repo = gitea.create_repo(org, 'test-repo', 'descr')
    assert repo.description == 'descr'
    assert repo.owner == org
    assert repo.name == 'test-repo'
    assert not repo.private


def test_create_team():
    org = Organization(gitea, 'test-org')
    team = gitea.create_team(org, 'test-team', 'descr')
    assert team.name == 'test-team'
    assert team.description == 'descr'
    assert team.organization == org

def test_full():
    user = User(gitea, 'test-user')
    user.update_mail()
    org = Organization(gitea, 'test-org')
    team = Team(org, 'test-team')
    assert team.get_members() == []
    team.add(user)
    assert team.get_members() == [user]
    repo = Repository(gitea, org, 'test-repo')
    assert team.get_repos() == []
    team.add(repo)
    assert team.get_repos() == [repo]


def test_delete_repo():
    org = Organization(gitea, 'test-org')
    repo = Repository(gitea, org, 'test-repo')
    repo.delete()
    assert expect_not_exist(
        lambda: Repository(gitea, User(gitea, "test-user"), "test-repo"),
        (NotFoundException),
    ), "Repository test-repo should not exist"

def test_delete_team():
    org = Organization(gitea, 'test-org')
    team = Team(org, 'test-team')
    team.delete()
    assert expect_not_exist(
        lambda: Team(org, "test-team"),
        (NotFoundException),
    ), "Team test-team should not exist"

def test_delete_org():
    org = Organization(gitea, 'test-org')
    org.delete()
    assert expect_not_exist(
        lambda: Organization(gitea, "test-org"), (NotFoundException)
    ), "Organization test-org should not exist"


def test_delete_user():
    user = User(gitea, 'test-user')
    user.delete()
    assert expect_not_exist(
        lambda: User(gitea, "test-user"), (NotFoundException)
    ), "User test-user should not exist"