# Copyright © 2022 Aravinth Manivannan <realaravinth@batsense.net>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
from check.forge import Forge
from check.entity import User, Repo, Org


class DummyForge(Forge):
    def __init__(self):
        super().__init__()
        self.users = [
            User(username="paying_user1"),
            User(username="paying_user2"),
            User(username="paying_user3"),
            User(username="no-paying_user1"),
            User(username="no-paying_user2"),
            User(username="no-paying_user3"),
        ]

        self.orgs = [
            Org(username="org1"),
            Org(username="org2"),
            Org(username="org3"),
        ]

        self.org_members_matrix = {}

        # 50:50::paying:non-paying
        self.org_members_matrix[self.orgs[0].username] = [
            self.users[0],
            self.users[1],
            self.users[3],
            self.users[4],
        ]

        # paying < non-paying
        self.org_members_matrix[self.orgs[1].username] = [
            self.users[0],
            self.users[3],
            self.users[4],
            self.users[5],
        ]

        # paying > non-paying
        self.org_members_matrix[self.orgs[2].username] = [
            self.users[0],
            self.users[1],
            self.users[2],
            self.users[5],
        ]

        self.repos = [
            Repo(
                owner=self.users[0].username,
                name="repo1",
                is_private=False,
                is_fork=False,
                parent=None,
            ),
            Repo(
                owner=self.users[1].username,
                name="repo2",
                is_private=False,
                is_fork=False,
                parent=None,
            ),
            Repo(
                owner=self.users[2].username,
                name="repo3",
                is_private=False,
                is_fork=True,
                parent=None,
            ),
            Repo(
                owner=self.users[3].username,
                name="repo4",
                is_private=False,
                is_fork=False,
                parent=None,
            ),
        ]
        self.repos.append(
            Repo(
                owner=self.users[4].username,
                name="repo5",
                is_private=False,
                is_fork=True,
                parent={
                    "owner": {
                        "username": self.repos[2].owner,
                    },
                    "name": self.repos[2].name,
                },
            )
        )

        self.repos.append(
            Repo(
                owner=self.users[5].username,
                name="repo6",
                is_private=False,
                is_fork=True,
                parent={
                    "owner": {
                        "username": self.repos[3].owner,
                    },
                    "name": self.repos[3].name,
                },
            )
        )

    def get_all_users(self) -> [User]:
        """
        Get all users on a forge instance
        """
        return self.users

    def get_all_orgs(self) -> [Org]:
        """
        Get all organisations on a Gitea instance
        """
        return self.orgs

    def get_repo(self, owner: str, name: str) -> Repo:
        """
        Get repository from forge
        """
        for repo in self.repos:
            if all([repo.owner == owner, repo.name == name]):
                return repo
        return None

    def get_all_user_repos(self, username: str) -> [Repo]:
        """
        Get all repositories that belong to a user on forge
        """
        repos = []
        for repo in self.repos:
            if repo.owner == username:
                repos.append(repo)

        return repos

    def org_members(self, org_name: str) -> [User]:
        """
        Get members of a Gitea organisation
        """
        return self.org_members_matrix[org_name]

    def get_user(self, username: str) -> User:
        """
        Get user from a forge instance
        """
        for user in self.users:
            if user.username == username:
                return user
        return None


def test_forge():
    forge = DummyForge()

    assert forge.get_user(forge.users[1].username) is forge.users[1]
    assert forge.get_user(username="nouser") is None

    assert (
        forge.org_members(org_name=forge.orgs[0].username)
        is forge.org_members_matrix[forge.orgs[0].username]
    )

    assert forge.get_all_user_repos(username=forge.users[1].username) == [
        forge.repos[1]
    ]

    assert (
        forge.get_repo(owner=forge.repos[0].owner, name=forge.repos[0].name)
        is forge.repos[0]
    )
    assert forge.get_repo(owner="nouser", name="norepo") is None
    assert forge.get_repo(owner=forge.repos[0].owner, name="norepo") is None
    assert forge.get_repo(owner="norepo", name=forge.repos[0].name) is None

    assert forge.get_all_orgs() is forge.orgs
    assert forge.get_all_users() is forge.users