import argparse
import sys
from abc import ABC, abstractmethod
from textwrap import dedent

from envyaml import EnvYAML


class AtlassianConnector(ABC):
    @abstractmethod
    def connect(self):
        pass

    @abstractmethod
    def _jira_connect(self):
        pass

    @abstractmethod
    def _confluence_connect(self):
        pass


class AtlassianManager(AtlassianConnector):
    def __init__(
        self, atlassian_server: str, atlassian_username: str, api_token: str, option: str
    ):
        self.__params = {
            "url": atlassian_server,
            "username": atlassian_username,
            "password": api_token,
        }
        self._atlassian_option = option
        self._jira_connection = None
        self._confluence_connection = None

    def connect(self):
        connectors = {
            "jira": self._jira_connect(),
            "confluence": self._confluence_connect(),
        }
        return connectors[self._atlassian_option]

    def _jira_connect(self):
        if not self._jira_connection:
            from atlassian import Jira

            self._jira_connection = Jira(**self.__params)
        return self._jira_connection

    def _confluence_connect(self):
        if not self._confluence_connection:
            from atlassian import Confluence

            self._confluence_connection = Confluence(**self.__params)
        return self._confluence_connection


# -----------------------------------------
class IssueUpdater:
    def __init__(self, jira_connector: AtlassianConnector):
        self._jira_connector = jira_connector

    def update_issues(self, issues: list):
        def _fields_to_update(issue_data: dict):
            fields_to_update = {}
            if "description" in issue_data:
                fields_to_update["description"] = issue_data["description"]
            if "acceptance_criteria" in issue_data:
                fields_to_update[acceptance_criteria_field_id] = issue_data[
                    "acceptance_criteria"
                ]
            if "summary" in issue_data:
                fields_to_update["summary"] = issue_data["summary"]
            return fields_to_update

        acceptance_criteria_field_id = self._get_acceptance_criteria_field_id()
        jira_connection = self._jira_connector.connect()
        for issue_data in issues:
            issue_key = issue_data["key"]
            issue = jira_connection.issue(issue_key)
            issue.update(fields=_fields_to_update(issue_data))
            print(f"Issue {issue_key} updated successfully!")

    def _get_acceptance_criteria_field_id(self):
        acceptance_criteria_field_id = [
            field["id"]
            for field in self._jira_connector.connect().fields()
            if field["name"].lower() == "acceptance criteria"
        ][0]
        return acceptance_criteria_field_id


class ConfluencePageCreator:
    def __init__(self, confluence_connector: AtlassianConnector):
        self._confluence_connector = confluence_connector

    def create_page(self, config: dict):
        confluence_connection = self._confluence_connector.connect()
        space_key = config["space_key"]
        body = config["template"].get("body", "h1. update page heading.")
        parent_id = config["template"].get("parent_id")
        for title in config["create_pages"]:
            try:
                result = confluence_connection.create_page(
                    space_key,
                    title,
                    body,
                    parent_id=parent_id,
                    type="page",
                    representation="wiki",
                )
                print(f"Page {result['title']} created successfully!")
            except Exception:
                print(f"Error creating page {title}")


# ----------------------------------------
class ConfigurationLoader:
    @staticmethod
    def load_config(filename):
        try:
            return EnvYAML(filename)
        except ValueError:
            print(
                dedent(
                    """
                    Environment Variables are not defined!
                    Ensure that you export the envvar before running the script.

                    -----------
                    export JIRA_API_TOKEN=$(cat ~/.secrets/jira_api.token)"""
                )
            )
            sys.exit(1)
        except Exception as e:
            raise Exception(f"Error loading configuration: {str(e)}")


def arguments():
    parser = argparse.ArgumentParser(add_help=False)
    parser.add_argument(
        "-c",
        "--config",
        default="./Config.yaml",
        type=str,
        required=True,
        help="Path to configuration file (Default: %(default)s)",
    )
    parser.add_argument(
        "--choice",
        type=str,
        required=True,
        choices=["issue", "confluence"],
        help="Interact with jira or confluence",
    )

    args = parser.parse_args()
    if len(sys.argv) == 1:
        parser.print_help()
        parser.exit(1)
    return args


if __name__ == "__main__":
    args = arguments()
    config = ConfigurationLoader.load_config(args.config)

    connection_config = config["connection"]
    atlassian_manager = AtlassianManager(
        atlassian_server=connection_config["atlassian_server"],
        atlassian_username=connection_config["atlassian_username"],
        api_token=connection_config["atlassian_api_token"],
        option=args.choice,
    )
    if args.choice == "issue":
        if config["jira"].get("update_issues"):
            issue_updater = IssueUpdater(atlassian_manager)
            issue_updater.update_issues(config["update_issues"])
    elif args.choice == "confluence":
        if config["confluence"].get("create_pages"):
            confluence_page_creator = ConfluencePageCreator(atlassian_manager)
            confluence_page_creator.create_page(config["confluence"])