'''

    Command line behavior for centpkg

'''

#

# Author(s):

#            Jesse Keating <jkeating@redhat.com>

#            Pat Riehecky <riehecky@fnal.gov>

#            Brian Stinson <bstinson@ksu.edu>

#

# This program is free software; you can redistribute it and/or modify it

# under the terms of the GNU General Public License as published by the

# Free Software Foundation; either version 2 of the License, or (at your

# option) any later version.  See http://www.gnu.org/copyleft/gpl.html for

# the full text of the license.

from __future__ import print_function

import argparse

import textwrap

from centpkg.utils import config_get_safely, do_add_remote, do_fork

import centpkg.utils

from pyrpkg.cli import cliClient

from pyrpkg import rpkgError

from urllib.parse import urlparse

from configparser import ConfigParser

import gitlab

import json

import os

import sys

_DEFAULT_API_BASE_URL = 'https://gitlab.com'

class centpkgClient(cliClient):

    def __init__(self, config, name='centpkg'):

        self.DEFAULT_CLI_NAME = name

        # Save the config for utilities such as get_repo_name()

        centpkg.utils.dist_git_config = config

        centpkg.utils.dist_git_config.add_section('__default')

        centpkg.utils.dist_git_config.set('__default', 'cli_name', name)

        super(centpkgClient, self).__init__(config, name)

        self.setup_centos_subparsers()

    def setup_centos_subparsers(self):

        self.register_do_fork()

        self.register_request_gated_side_tag()

        self.register_current_state()

    def register_do_fork(self):

        help_msg = 'Create a new fork of the current repository'

        distgit_section = '{0}.distgit'.format(self.name)

        # uses default dist-git url in case section is not present

        try:

            distgit_api_base_url = config_get_safely(self.config, distgit_section, "apibaseurl")

        except rpkgError:

            distgit_api_base_url = _DEFAULT_API_BASE_URL

        description = textwrap.dedent('''

            Create a new fork of the current repository

            Before the operation, you need to generate an API token at

            https://{1}/-/profile/personal_access_tokens, select the "api"

            scope and save it in your local user configuration located

            at ~/.config/rpkg/{0}.conf. For example:

                [{0}.distgit]

                token = <api_key_here>

            Below is a basic example of the command to fork a current repository:

                {0} fork

        '''.format(self.name, urlparse(distgit_api_base_url).netloc))

        fork_parser = self.subparsers.add_parser(

            'fork',

            formatter_class=argparse.RawDescriptionHelpFormatter,

            help=help_msg,

            description=description)

        fork_parser.set_defaults(command=self.do_distgit_fork)

    def do_distgit_fork(self):

        """create fork of the distgit repository

        That includes creating fork itself using API call and then adding

        remote tracked repository

        """

        distgit_section = '{0}.distgit'.format(self.name)

        distgit_api_base_url = config_get_safely(self.config, distgit_section, "apibaseurl")

        distgit_token = config_get_safely(self.config, distgit_section, 'token')

        ret, repo_path = do_fork(

            logger=self.log,

            base_url=distgit_api_base_url,

            token=distgit_token,

            repo_name=self.cmd.repo_name,

            namespace=self.cmd.ns,

            cli_name=self.name,

        )

        # assemble url of the repo in web browser

        fork_url = '{0}/{1}'.format(

            distgit_api_base_url.rstrip('/'),

            repo_path,

        )

        if ret:

            msg = "Fork of the repository has been created: '{0}'"

        else:

            msg = "Repo '{0}' already exists."

        self.log.info(msg.format(fork_url))

        distgit_remote_base_url = self.config.get(

            '{0}'.format(self.name),

            "gitbaseurl",

            vars={'repo': '{0}/{1}'.format(self.cmd.ns, self.cmd.repo_name)},

        )

        remote_name = repo_path.split('/')[0]

        ret = do_add_remote(

            base_url=distgit_api_base_url,

            remote_base_url=distgit_remote_base_url,

            repo=self.cmd.repo,

            repo_path=repo_path,

            remote_name=remote_name,

        )

        if ret:

            msg = "Adding as remote '{0}'."

        else:

            msg = "Remote with name '{0}' already exists."

        self.log.info(msg.format(remote_name))

    def register_current_state(self):

        """Register command line parser for subcommand current-state"""

        parser = self.subparsers.add_parser(

            "current-state",

            help="Show the phase and state of current dist-git branch - Internal Only",

        )

        parser.set_defaults(command=self.request_current_state)

    # FIXME: This is alot of duplication.

    #        Get it working now.  De-duplicate later

    def request_current_state(self):

        # Only run if we have internal configuraions, or scratch

        internal_config_file = "/etc/rpkg/centpkg_internal.conf"

        if os.path.exists(internal_config_file):

            # Get our internal only variables

            cfg = ConfigParser()

            cfg.read(internal_config_file)

            pp_api_url = config_get_safely(cfg, "centpkg.internal", 'pp_api_url')

            gitbz_query_url = config_get_safely(cfg, "centpkg.internal", 'gitbz_query_url')

            rhel_dist_git = config_get_safely(cfg, "centpkg.internal", 'rhel_dist_git')

            # Find out divergent branch and stabalization

            self.log.info("Checking current state:")

            stream_version = self.cmd.target.split('-')[0]

            rhel_version = centpkg.utils.stream_mapping(stream_version)

            try:

                x_version, active_y, is_beta, in_stabilization = centpkg.utils.determine_active_y_version(rhel_version, pp_api_url)

            except AssertionError as e:

                self.log.error("  Error: centpkg cannot determine the development phase.")

                self.log.error("         Please file an issue at https://git.centos.org/centos/centpkg")

                self.log.error("  Workaround: Use the --rhel-target option")

                self.log.error("Exiting")

                raise SystemExit(1)

            if is_beta:

                # Special case: for X.0 betas, there will never be a prior branch

                # In this case, always work on the active branch.

                divergent_branch = True

            else:

                divergent_branch = centpkg.utils.does_divergent_branch_exist(

                                        self.cmd.repo_name,

                                        x_version,

                                        active_y,

                                        rhel_dist_git,

                                        "rpms")

            # Good to know

            if in_stabilization :

                self.log.info("    we are in stabilization mode.")

            else:

                self.log.info("    we are not in stabilization mode.")

            if divergent_branch and not is_beta:

                self.log.info("    a divergent branch was found.")

            elif divergent_branch and is_beta:

                self.log.info("    we are working on a beta release.")

            else:

                self.log.info("    a divergent branch was not found.")

        else:

            self.log.error("NO INTERNAL CONFIGURATION")

            self.log.error("Hint: If you are internal, install the rhel-packager package from https://download.devel.redhat.com/rel-eng/RCMTOOLS/latest-RCMTOOLS-2-RHEL-9/compose/BaseOS/x86_64/os/Packages/")

            self.log.error("Exiting")

            raise SystemExit(1)

    # Overloaded build

    def register_build(self):

        # Do all the work from the super class

        super(centpkgClient, self).register_build()

        build_parser = self.subparsers.choices['build']

        build_parser.formatter_class = argparse.RawDescriptionHelpFormatter

        build_parser.description = textwrap.dedent('''

            {0}

            centpkg now sets the rhel metadata with --rhel-target.

             * exception - This will build for the current in-development Y-stream release.

               It is equivalent to passing latest when not in the Blocker and Exception Phase.

             * zstream - If pre-GA of a y-stream release, this will build for 0day.

               If post-GA of a Y-stream release, this will build for the Z-stream of that release.

             * latest - This will always build for the next Y-stream release

             * none - This will not build in brew.  No rhel metadata is set.

        '''.format('\n'.join(textwrap.wrap(build_parser.description))))

        # Now add our additional option

        build_parser.add_argument(

            '--rhel-target',

            choices=['exception', 'zstream', 'latest', 'none'],

            help='Set the rhel-target metadata')

    # Overloaded _build

    def _build(self, sets=None):

        # Only do rhel-target if we are centpkg, not centpkg-sig, or if we are doing scratch

        if not os.path.basename(sys.argv[0]).endswith('-sig') and not self.args.scratch:

            # Only run if we have internal configuraions

            internal_config_file = "/etc/rpkg/centpkg_internal.conf"

            if os.path.exists(internal_config_file):

                # If rhel-target is set, no need to check, just use it

                if hasattr(self.args, 'rhel_target') and self.args.rhel_target:

                    # If rhel-target set to none, do nothing with metadata

                    if self.args.rhel_target.lower() != "none":

                        # If custom-user-metadata set, add onto it

                        if hasattr(self.args, 'custom_user_metadata') and self.args.custom_user_metadata:

                            try:

                                temp_custom_user_metadata = json.loads(self.args.custom_user_metadata)

                            # Use ValueError instead of json.JSONDecodeError for Python 2 and 3 compatibility

                            except ValueError as e:

                                self.parser.error("--custom-user-metadata is not valid JSON: %s" % e)

                            if not isinstance(temp_custom_user_metadata, dict):

                                self.parser.error("--custom-user-metadata must be a JSON object")

                            temp_custom_user_metadata["rhel-target"] = self.args.rhel_target

                        else:

                            temp_custom_user_metadata = {"rhel-target": self.args.rhel_target}

                        self.args.custom_user_metadata = json.dumps(temp_custom_user_metadata)

                else:

                    # Get our internal only variables

                    cfg = ConfigParser()

                    cfg.read(internal_config_file)

                    pp_api_url = config_get_safely(cfg, "centpkg.internal", 'pp_api_url')

                    gitbz_query_url = config_get_safely(cfg, "centpkg.internal", 'gitbz_query_url')

                    rhel_dist_git = config_get_safely(cfg, "centpkg.internal", 'rhel_dist_git')

                    # Find out divergent branch and stabalization

                    self.log.info("Checking rhel-target information:")

                    stream_version = self.cmd.target.split('-')[0]

                    rhel_version = centpkg.utils.stream_mapping(stream_version)

                    try:

                        x_version, active_y, is_beta, in_stabilization = centpkg.utils.determine_active_y_version(rhel_version, pp_api_url)

                    except AssertionError as e:

                        self.log.error("  Error: centpkg cannot determine the development phase.")

                        self.log.error("         Please file an issue at https://git.centos.org/centos/centpkg")

                        self.log.error("  Workaround: Use the --rhel-target option")

                        self.log.error("Exiting")

                        raise SystemExit(1)

                    if is_beta:

                        # Special case: for X.0 betas, there will never be a prior branch

                        # In this case, always work on the active branch.

                        divergent_branch = True

                    else:

                        divergent_branch = centpkg.utils.does_divergent_branch_exist(

                                                self.cmd.repo_name,

                                                x_version,

                                                active_y,

                                                rhel_dist_git,

                                                "rpms")

                    # Good to know

                    if divergent_branch and not is_beta:

                        self.log.info("    a divergent branch was found.")

                    elif divergent_branch and is_beta:

                        self.log.info("    we are working on a beta release.")

                    else:

                        self.log.info("    a divergent branch was not found.")

                    if in_stabilization :

                        self.log.info("    we are in stabilization mode.")

                    else:

                        self.log.info("    we are not in stabilization mode.")

                    # Update args.custom_user_metadata

                    if hasattr(self.args, 'custom_user_metadata') and self.args.custom_user_metadata:

                        try:

                            temp_custom_user_metadata = json.loads(self.args.custom_user_metadata)

                        # Use ValueError instead of json.JSONDecodeError for Python 2 and 3 compatibility

                        except ValueError as e:

                            self.parser.error("--custom-user-metadata is not valid JSON: %s" % e)

                        if not isinstance(temp_custom_user_metadata, dict):

                            self.parser.error("--custom-user-metadata must be a JSON object")

                        if divergent_branch:

                            temp_custom_user_metadata["rhel-target"] = "latest"

                        elif not divergent_branch and not in_stabilization :

                            temp_custom_user_metadata["rhel-target"] = "zstream"

                        else:

                            self.log.error("We are currently in Stabalization mode")

                            self.log.error("You must either set the rhel-target (--rhel-target)")

                            self.log.error("or branch for the previous version.")

                            self.log.error("Exiting")

                            raise SystemExit(1)

                        self.args.custom_user_metadata = json.dumps(temp_custom_user_metadata)

                    else:

                        if divergent_branch:

                            self.args.custom_user_metadata = '{"rhel-target": "latest"}'

                        elif not divergent_branch and not in_stabilization :

                            self.args.custom_user_metadata = '{"rhel-target": "zstream"}'

                        else:

                            self.log.error("We are currently in Stabalization mode")

                            self.log.error("You must either set the rhel-target (--rhel-target)")

                            self.log.error("or branch for the previous version.")

                            self.log.error("Exiting")

                            raise SystemExit(1)

                    # Good to know

                    self.log.info("    rhel-target: " + json.loads(self.args.custom_user_metadata)['rhel-target'])

            else:

                self.log.error("NO INTERNAL CONFIGURATION")

                self.log.error("Only scratch builds are allowed without internal configurations")

                self.log.error("Hint: Install the rhel-packager package from https://download.devel.redhat.com/rel-eng/RCMTOOLS/latest-RCMTOOLS-2-RHEL-9/compose/BaseOS/x86_64/os/Packages/ if you want to build the package via internal (Red Hat) configuration.")

                self.log.error("Exiting")

                raise SystemExit(1)

        # Proceed with build

        return super(centpkgClient, self)._build(sets)

    def register_request_gated_side_tag(self):

        """Register command line parser for subcommand request-gated-side-tag"""

        parser = self.subparsers.add_parser(

            "request-gated-side-tag",

            help="Create a new dynamic gated side tag",

        )

        parser.add_argument("--base-tag", help="name of base tag")

        parser.set_defaults(command=self.request_gated_side_tag)

    def request_gated_side_tag(self):

        self.args.suffix = "stack-gate"

        super(centpkgClient, self).request_side_tag()

    def clone(self):

        # Since gitlab allows git repos to be checked out with incorrect capitilization

        #   we need to check the spelling when cloning

        gl = gitlab.Gitlab(_DEFAULT_API_BASE_URL)

        if "/" in self.args.repo[0]:

            project_name_with_namespace = "redhat/centos-stream/"+self.args.repo[0]

            short_name=self.args.repo[0].split("/")[1]

        else:

            project_name_with_namespace = "redhat/centos-stream/rpms/"+self.args.repo[0]

            short_name=self.args.repo[0]

        try:

            project = gl.projects.get(project_name_with_namespace)

        except gitlab.exceptions.GitlabGetError as e:

            self.log.error("There is no repository with the given name. Did you spell it correctly?")

            self.log.error("Fatal: ")

            self.log.error(e)

            raise SystemExit(1)

        if not project.name == short_name:

            self.log.error("Fatal: ")

            self.log.error("Project name is wrong: " + short_name + " it should be: " + project.name)

            raise SystemExit(1)

        super(centpkgClient, self).clone()