#!/usr/bin/python

"""Copyright 2011 Gentoo Foundation
Distributed under the terms of the GNU General Public License v2
"""

from __future__ import print_function

""" Meta """
__author__ = "Corentin Chary (iksaif)"
__email__ = "corentin.chary@gmail.com"
__version__ = "git"
__productname__ = "euscan"
__description__ = "A tool to detect new upstream releases."
__version__ = "git"

""" Imports """

import sys
import getopt
import errno
import httplib

from portage.output import white, yellow, turquoise, green, EOutput
from portage.exception import AmbiguousPackageName

from gentoolkit import pprinter as pp
from gentoolkit.eclean.search import (port_settings)
from gentoolkit.errors import GentoolkitException

import euscan
from euscan import CONFIG
from euscan.scan import scan_upstream

""" Globals """


def setupSignals():
    """ This block ensures that ^C interrupts are handled quietly. """
    import signal

    def exithandler(signum, frame):
        signal.signal(signal.SIGINT, signal.SIG_IGN)
        signal.signal(signal.SIGTERM, signal.SIG_IGN)
        print ()
        sys.exit(errno.EINTR)

    signal.signal(signal.SIGINT, exithandler)
    signal.signal(signal.SIGTERM, exithandler)
    signal.signal(signal.SIGPIPE, signal.SIG_DFL)


def printVersion():
    """Output the version info."""
    print("%s (%s) - %s" \
            % (__productname__, __version__, __description__))
    print()
    print("Author: %s <%s>" % (__author__, __email__))
    print("Copyright 2011 Gentoo Foundation")
    print("Distributed under the terms of the GNU General Public License v2")


def printUsage(_error=None, help=None):
    """Print help message. May also print partial help to stderr if an
    error from {'options'} is specified."""

    out = sys.stdout
    if _error:
        out = sys.stderr
    if not _error in ('global-options', 'packages',):
        _error = None
    if not _error and not help:
        help = 'all'
    if _error in ('global-options',):
        print(pp.error("Wrong option on command line."), file=out)
        print(file=out)
    if _error in ('packages',):
        print(pp.error("You need to specify exactly one package."), file=out)
        print(file=out)
    print(white("Usage:"), file=out)
    if _error in ('global-options', 'packages',) or help == 'all':
        print(" " + turquoise(__productname__),
               yellow("[options]"),
               green("<package> [<package> [...]]"), file=out)
    if _error in ('global-options',) or help == 'all':
        print(" " + turquoise(__productname__),
               yellow("[--help, --version]"), file=out)

    print(file=out)
    if _error in ('global-options',) or help:
        print("Available ", yellow("options") + ":", file=out)
        print(yellow(" -C, --nocolor") +
            "             - turn off colors on output", file=out)
        print(yellow(" -q, --quiet") +
            "               - be as quiet as possible", file=out)
        print(yellow(" -h, --help") +
            "                - display the help screen", file=out)
        print(yellow(" -V, --version") +
            "             - display version info", file=out)
        print(file=out)
        print(yellow(" -1, --oneshot") +
            "             - stop as soon as a new version is found",
            file=out)
        print(yellow(" -b, --brute-force=<level>") +
            " - define the brute force " + yellow("<level>") +
            " (default: 2)\n" +
            " " * 29 + "bigger levels will generate more versions numbers\n" +
            " " * 29 + "0 means disabled", file=out)
        print(file=out)
    if _error in ('packages',) or help:
        print(green(" package") +
            "                   - the packages (or ebuilds) you want to scan",
            file=out)
        print(file=out)
        '''print( "More detailed instruction can be found in",
        turquoise("`man %s`" % __productname__), file=out)'''


class ParseArgsException(Exception):
    """For parseArgs() -> main() communications."""
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return repr(self.value)


def parseArgs():
    """Parse the command line arguments. Raise exceptions on
    errors. Returns package and affect the CONFIG dict.
    """

    def optionSwitch(opts):
        """local function for interpreting command line options
        and setting options accordingly"""
        return_code = True
        for o, a in opts:
            if o in ("-h", "--help"):
                raise ParseArgsException('help')
            elif o in ("-V", "--version"):
                raise ParseArgsException('version')
            elif o in ("-C", "--nocolor"):
                CONFIG['nocolor'] = True
                pp.output.nocolor()
            elif o in ("-q", "--quiet"):
                CONFIG['quiet'] = True
                CONFIG['verbose'] = 0
            elif o in ("-1", "--oneshot"):
                CONFIG['oneshot'] = True
            elif o in ("-b", "--brute-force"):
                CONFIG['brute-force'] = int(a)
            elif o in ("-v", "--verbose") and not CONFIG['quiet']:
                    CONFIG['verbose'] += 1
            else:
                return_code = False

        return return_code

    ' here are the different allowed command line options (getopt args) '
    getopt_options = {'short': {}, 'long': {}}
    getopt_options['short']['global'] = "hVCqv1b:"
    getopt_options['long']['global'] = ["help", "version", "nocolor", "quiet",
                        "verbose", "oneshot", "brute-force="]

    short_opts = getopt_options['short']['global']
    long_opts = getopt_options['long']['global']
    opts_mode = 'global'

    ' apply getopts to command line, show partial help on failure '
    try:
        opts, args = getopt.getopt(sys.argv[1:], short_opts, long_opts)
    except:
        raise ParseArgsException(opts_mode + '-options')

    ' set options accordingly '
    optionSwitch(opts)

    if len(args) < 1:
        raise ParseArgsException('packages')

    return args


def main():
    """Parse command line and execute all actions."""
    CONFIG['nocolor'] = (port_settings["NOCOLOR"] in ('yes', 'true')
        or not sys.stdout.isatty())
    if CONFIG['nocolor']:
        pp.output.nocolor()
    ' parse command line options and actions '
    try:
        packages = parseArgs()
    except ParseArgsException as e:
        if e.value == 'help':
            printUsage(help='all')
            sys.exit(0)
        elif e.value[:5] == 'help-':
            printUsage(help=e.value[5:])
            sys.exit(0)
        elif e.value == 'version':
            printVersion()
            sys.exit(0)
        else:
            printUsage(e.value)
            sys.exit(errno.EINVAL)

    """ Change euscan's output """
    euscan.output = EOutput(CONFIG['quiet'])
    if CONFIG['verbose'] > 2:
        httplib.HTTPConnection.debuglevel = 1

    for package in packages:
        ret = []

        try:
            ret = scan_upstream(package)
        except AmbiguousPackageName as e:
            pkgs = e.args[0]
            for candidate in pkgs:
                print(candidate)

            from os.path import basename  # To get the short name

            print(file=sys.stderr)
            print(
                pp.error(
                    "The short ebuild name '%s' is ambiguous. Please specify" \
                    % basename(pkgs[0])
                ),
                file=sys.stderr, end=""
            )
            pp.die(1, "one of the above fully-qualified ebuild names instead.")
        except GentoolkitException as err:
            pp.die(1, '%s: %s' % (package, str(err)))
        except Exception as err:
            pp.die(1, '%s: %s' % (package, str(err)))

        if not CONFIG['quiet']:
            print ()

        for cp, url, version in ret:
            if not CONFIG['quiet']:
                print ("Upstream Version: "
                       + pp.number("%s" % version)
                       + pp.path(" %s" % url))
            else:
                print (pp.cpv("%s-%s" % (cp, version))
                       + ": " + pp.path(url))

        if not len(ret) and not CONFIG['quiet']:
            print (pp.warn("Didn't find any new version, "
                           + "check package's homepage for "
                           + "more informations"))


if __name__ == "__main__":
    try:
        setupSignals()
        main()
    except KeyboardInterrupt:
        print("Aborted.")
        sys.exit(errno.EINTR)
    sys.exit(0)
