# Copyright 2005 Duke University

# Copyright (C) 2012-2016 Red Hat, Inc.

#

# 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.

#

# 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 Library General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

"""

Entrance point for the yum command line interface.

"""

from __future__ import print_function

from __future__ import absolute_import

from __future__ import unicode_literals

from dnf.conf import Conf

from dnf.cli.cli import Cli

from dnf.cli.option_parser import OptionParser

from dnf.i18n import ucd

from dnf.cli.utils import show_lock_owner

from dnf.i18n import _

import dnf.cli

import dnf.cli.cli

import dnf.cli.option_parser

import dnf.exceptions

import dnf.i18n

import dnf.logging

import dnf.util

import errno

import hawkey

import libdnf.error

import logging

import os

import os.path

import sys

logger = logging.getLogger("dnf")

def ex_IOError(e):

    logger.log(dnf.logging.SUBDEBUG, '', exc_info=True)

    logger.critical(ucd(e))

    return 1

def ex_Error(e):

    logger.log(dnf.logging.SUBDEBUG, '', exc_info=True)

    if e.value is not None:

        logger.critical(_('Error: %s'), ucd(e))

    return 1

def main(args, conf_class=Conf, cli_class=Cli, option_parser_class=OptionParser):

    try:

        dnf.i18n.setup_stdout()

        with dnf.cli.cli.BaseCli(conf_class()) as base:

            return _main(base, args, cli_class, option_parser_class)

    except dnf.exceptions.ProcessLockError as e:

        logger.critical(e.value)

        show_lock_owner(e.pid)

        return 200

    except dnf.exceptions.LockError as e:

        logger.critical(e.value)

        return 200

    except dnf.exceptions.DepsolveError as e:

        return 1

    except dnf.exceptions.Error as e:

        return ex_Error(e)

    except hawkey.Exception as e:

        logger.critical(_('Error: %s'), ucd(e))

        return 1

    except libdnf.error.Error as e:

        logger.critical(_('Error: %s'), ucd(e))

        return 1

    except IOError as e:

        return ex_IOError(e)

    except KeyboardInterrupt as e:

        logger.critical('{}: {}'.format(type(e).__name__, _("Terminated.")))

        return 1

def _main(base, args, cli_class, option_parser):

    """Run the dnf program from a command line interface."""

    # our core object for the cli

    base._logging._presetup()

    cli = cli_class(base)

    # do our cli parsing and config file setup

    # also sanity check the things being passed on the cli

    try:

        cli.configure(list(map(ucd, args)), option_parser())

    except (IOError, OSError) as e:

        return ex_IOError(e)

    return cli_run(cli, base)

def cli_run(cli, base):

    # Try to open the current directory to see if we have

    # read and execute access. If not, chdir to /

    try:

        f = open(".")

    except IOError as e:

        if e.errno == errno.EACCES:

            logger.critical(_('No read/execute access in current directory, moving to /'))

            os.chdir("/")

    else:

        f.close()

    try:

        cli.run()

    except dnf.exceptions.LockError:

        raise

    except (IOError, OSError) as e:

        return ex_IOError(e)

    if cli.demands.resolving:

        try:

            ret = resolving(cli, base)

        except dnf.exceptions.DepsolveError as e:

            ex_Error(e)

            msg = ""

            if not cli.demands.allow_erasing and base._goal.problem_conflicts(available=True):

                msg += _("try to add '{}' to command line to replace conflicting "

                         "packages").format("--allowerasing")

            if cli.base.conf.strict:

                if not msg:

                    msg += _("try to add '{}' to skip uninstallable packages").format(

                        "--skip-broken")

                else:

                    msg += _(" or '{}' to skip uninstallable packages").format("--skip-broken")

            if cli.base.conf.best:

                prio = cli.base.conf._get_priority("best")

                if prio <= dnf.conf.PRIO_MAINCONFIG:

                    if not msg:

                        msg += _("try to add '{}' to use not only best candidate packages").format(

                            "--nobest")

                    else:

                        msg += _(" or '{}' to use not only best candidate packages").format(

                            "--nobest")

            if msg:

                logger.info("({})".format(msg))

            raise

        if ret:

            return ret

    cli.command.run_transaction()

    return cli.demands.success_exit_status

def resolving(cli, base):

    """Perform the depsolve, download and RPM transaction stage."""

    if base.transaction is None:

        base.resolve(cli.demands.allow_erasing)

        logger.info(_('Dependencies resolved.'))

    cli.command.run_resolved()

    # Run the transaction

    displays = []

    if cli.demands.transaction_display is not None:

        displays.append(cli.demands.transaction_display)

    try:

        base.do_transaction(display=displays)

    except dnf.cli.CliError as exc:

        logger.error(ucd(exc))

        return 1

    except dnf.exceptions.TransactionCheckError as err:

        for msg in cli.command.get_error_output(err):

            logger.critical(msg)

        return 1

    except IOError as e:

        return ex_IOError(e)

    else:

        logger.info(_('Complete!'))

    return 0

def user_main(args, exit_code=False):

    """Call one of the multiple main() functions based on environment variables.

    :param args: command line arguments passed into yum

    :param exit_code: if *exit_code* is True, this function will exit

       python with its exit code when it has finished executing.

       Otherwise, it will return its exit code.

    :return: the exit code from dnf.yum execution

    """

    errcode = main(args)

    if exit_code:

        sys.exit(errcode)

    return errcode

if __name__ == "__main__":

    user_main(sys.argv[1:], exit_code=True)