#! /usr/bin/python3
'''
Usage: %(appname)s [-hVvdm] [-j N] [PRJ]
       %(appname)s [-hVvdm] [-j N] OLDPRJ NEWPRJ
       -h, --help           this message
       -V, --version        print version and exit
       -v, --verbose        verbose mode (cumulative)
       -d, --diff           produce diff files
       -m, --meta           compare meta data
       -j, --jobs N         parallel osc calls (default: 4)

The program operates in two modes:

Compare all packages in PRJ with local tree, run in checked out
project tree (osc diff). PRJ defaults to the project of the current
directory. Packages missing locally are reported, multibuild flavors
(pkg:flavor) are skipped.

Compare all packages of NEWPRJ with packages in OLDPRJ,
given they exist in both projects (osc rdiff). If you run this
in an obs tree, be aware, that osc fetches the server from it.

Copyright:
(c)2019-2026 by %(author)s

License:
%(license)s
'''
#
# vim:set et ts=8 sw=4:
#

__version__ = '0.4'
__author__ = 'Hans-Peter Jansen <hpj@urpla.net>'
__license__ = 'GNU GPL 2 - see http://www.gnu.org/licenses/gpl2.txt for details'


import os
import sys
import getopt
import logging
import logging.handlers
import subprocess
from concurrent.futures import ThreadPoolExecutor


class gpar:
    ''' global parameter class '''
    appdir, appname = os.path.split(sys.argv[0])
    if appdir == '.':
        appdir = os.getcwd()
    if appname.endswith('.py'):
        appname = appname[:-3]
    version = __version__
    author = __author__
    license = __license__
    loglevel = logging.ERROR
    oldrepo = []
    newrepo = []
    diff = False
    meta = False
    jobs = 4


log = logging.getLogger(gpar.appname)

# we need encoding failure tolerant i/o handling
seutf8 = lambda s: s.decode(encoding = 'utf-8',
                            errors = 'surrogateescape')
seopen = lambda fd: open(fd, 'w',
                         encoding = 'utf-8',
                         errors = 'surrogateescape',
                         closefd = False)

sys.stdout = seopen(1)
sys.stderr = seopen(2)

stdout = lambda *s: print(*s, file = sys.stdout, flush = True)
stderr = lambda *s: print(*s, file = sys.stderr, flush = True)


def die(ret = 0, msg = None, usage = False):
    ''' terminate process with optional message and usage '''
    if msg:
        stderr('%s: %s' % (gpar.appname, msg))
    if usage:
        stderr(__doc__ % gpar.__dict__)
    sys.exit(ret)


def setup_logging(loglevel):
    ''' setup various aspects of logging facility '''
    logconfig = dict(
        level = loglevel,
        format = '%(asctime)s %(levelname)5s: %(message)s',
        datefmt = '%Y-%m-%d %H:%M:%S',
    )
    logging.basicConfig(**logconfig)


def osc(*args, cwd = None):
    ''' run osc, return stdout ('' means: no output), None on failure '''
    cmd = ['osc']
    if gpar.loglevel <= logging.DEBUG:
        cmd.append('--debug')
    cmd.extend(args)
    log.debug('run: %s', ' '.join(cmd))
    # in order to handle encoding errors correctly,
    # we convert with surrogateescape manually
    res = subprocess.run(cmd, cwd = cwd, stdout = subprocess.PIPE,
                         stderr = subprocess.PIPE)
    out = seutf8(res.stdout)
    if res.returncode and not out:
        # don't mistake a failed call for "no differences"
        log.warning('%s failed (%s): %s', ' '.join(args), res.returncode,
                    seutf8(res.stderr).strip())
        return None
    return out


def osc_ls_repo(prj):
    ''' run osc ls, return the list of real packages (no flavors) '''
    res = osc('ls', prj)
    if res:
        return [r for r in res.split('\n') if r and ':' not in r]
    return []


def osc_args(cmd):
    return [cmd, '--meta'] if gpar.meta else [cmd]


def pmap(func, items):
    ''' run func on items in parallel, yield (item, result) in order '''
    with ThreadPoolExecutor(max_workers = max(gpar.jobs, 1)) as pool:
        yield from zip(items, pool.map(func, items))


def report(diff, difffile, header):
    ''' print diff or write it to difffile '''
    if not diff:
        return
    if gpar.diff:
        try:
            with open(difffile, 'w', encoding = 'utf-8',
                      errors = 'surrogateescape') as f:
                f.write(diff)
        except OSError:
            log.exception('cannot write %s:', difffile)
    else:
        stdout('%s\n%s' % (header, diff))


def local_project():
    ''' project name of the current checkout, if any '''
    try:
        with open('.osc/_project') as f:
            return f.read().strip()
    except OSError:
        return None


def prjdiff(prj = None):
    ''' run osc diff on all packages in this project,
        that exist locally and remote
    '''
    here = local_project()
    if not prj:
        prj = here
        if not prj:
            die(2, 'no PRJ given and not in a project checkout', True)
    elif here != prj:
        log.warning('current directory is %s, not %s', here or 'no project', prj)

    log.info('fetch: %s', prj)
    pkglst = osc_ls_repo(prj)
    if not pkglst:
        die(3, 'no packages in %s' % prj)

    cwd = os.getcwd()
    local = [p for p in pkglst if os.path.isdir(os.path.join(cwd, p, '.osc'))]
    for pkg in sorted(set(pkglst) - set(local)):
        log.warning('%s is not checked out in %s', pkg, cwd)
    for d in sorted(os.listdir(cwd)):
        if d not in pkglst and os.path.isdir(os.path.join(cwd, d, '.osc')):
            log.warning('%s exists locally, but not in %s', d, prj)

    def run(pkg):
        return osc(*osc_args('diff'), cwd = os.path.join(cwd, pkg))

    errors = 0
    for pkg, diff in pmap(run, local):
        log.info('process %s', pkg)
        if diff is None:
            errors += 1
        else:
            report(diff, '%s-%s.diff' % (prj, pkg),
                   'Differences in %s/%s:' % (prj, pkg))

    return 4 if errors else 0


def prjdiff2(oldprj, newprj):
    ''' run osc rdiff on all packages, that exist in both projects '''
    log.info('fetch: %s', oldprj)
    oldpkg = osc_ls_repo(oldprj)
    if not oldpkg:
        die(3, 'no packages in %s' % oldprj)

    log.info('fetch: %s', newprj)
    newpkg = osc_ls_repo(newprj)
    if not newpkg:
        die(3, 'no packages in %s' % newprj)

    for pkg in sorted(set(newpkg) - set(oldpkg)):
        log.warning('%s only in %s', pkg, newprj)
    for pkg in sorted(set(oldpkg) - set(newpkg)):
        log.info('%s only in %s', pkg, oldprj)

    common = [p for p in newpkg if p in oldpkg]

    def run(pkg):
        return osc(*osc_args('rdiff'), oldprj, pkg, newprj, pkg)

    errors = 0
    for pkg, diff in pmap(run, common):
        log.info('process %s', pkg)
        if diff is None:
            errors += 1
        else:
            report(diff, '%s-%s-%s.diff' % (oldprj, newprj, pkg),
                   'Differences of %s/%s and %s/%s:'
                   % (oldprj, pkg, newprj, pkg))

    return 4 if errors else 0


def main():
    ''' Command line interface and console script entry point '''
    try:
        optlist, args = getopt.getopt(sys.argv[1:], 'hVvdmj:',
            ('help', 'version', 'verbose', 'diff', 'meta', 'jobs=')
        )
    except getopt.error as msg:
        die(1, msg, True)

    for opt, par in optlist:
        if opt in ('-h', '--help'):
            die(usage = True)
        elif opt in ('-V', '--version'):
            die(msg = 'version %s' % gpar.version)
        elif opt in ('-v', '--verbose'):
            if gpar.loglevel > logging.DEBUG:
                gpar.loglevel -= 10
        elif opt in ('-d', '--diff'):
            gpar.diff = True
        elif opt in ('-m', '--meta'):
            gpar.meta = True
        elif opt in ('-j', '--jobs'):
            try:
                gpar.jobs = int(par)
            except ValueError:
                die(1, 'invalid job count: %s' % par, True)

    setup_logging(gpar.loglevel)

    try:
        if len(args) < 2:
            return prjdiff(*args)
        elif len(args) == 2:
            return prjdiff2(*args)
        else:
            die(2, 'invalid argument count: at most two expected', True)
    except KeyboardInterrupt:
        die(5, 'Canceled')
    except Exception:
        log.exception('internal error:')
        return 6


if __name__ == '__main__':
    sys.exit(main())
