#!/usr/bin/env python -u
from __future__ import absolute_import, print_function
import os
from argparse import ArgumentParser, FileType
from fnmatch import fnmatchcase
from shutil import rmtree
from subprocess import check_call, check_output, CalledProcessError
from tempfile import mkdtemp
import yaml
from candolint.utils import rel, timestamp
def run_ignore_codes(fn, args, codes, **kwargs):
    try:
        return fn(args, **kwargs)
    except CalledProcessError as e:
        if e.returncode not in codes:
            raise
        return e.output
def run(args, silent=False, get_output=False, ignore_codes=None, env=None):
    if get_output:
        fn = check_output
    else:
        fn = check_call
    if env:
        full_env = os.environ.copy()
        full_env.update(env)
    else:
        full_env = None
    try:
        if not silent:
            print('$ ' + ' '.join(args))
        if ignore_codes:
            result = run_ignore_codes(fn, args, ignore_codes, env=full_env)
        else:
            result = fn(args, env=full_env)
        if get_output:
            return result
        else:
            return True
    except Exception as e:
        print('# C&O error: {}'.format(e))
        return False
def run_git(args, **kwargs):
    env = kwargs.pop('env', {})
    env.update({'LC_ALL': 'en_US.UTF-8'})
    return run(['git'] + args, env=env, **kwargs)
def run_hg(args, **kwargs):
    env = kwargs.pop('env', {})
    env.update({'HGPLAIN': '1'})
    return run(['hg'] + args, env=env, **kwargs)
def read_linter_config(name, path=rel('linters')):
    try:
        fd = open(os.path.join(path, '{}.yml'.format(name)))
    except Exception as e:
        print("# C&O couldn't load linter config: {}".format(e))
        return None
    with fd:
        try:
            return yaml.safe_load(fd)
        except Exception as e:
            print("# C&O couldn't parse linter config: {}".format(e))
            return None
def prevalidate(config):
    ok = True
    if 'url' not in config:
        print("# C&O config doesn't have 'url' defined.")
        ok = False
    if 'scm' not in config:
        print("# C&O config doesn't have 'scm' defined.")
        ok = False
    elif config['scm'] not in ('git', 'hg'):
        print("# C&O checker doesn't support {} yet.".format(config['scm']))
        ok = False
    return ok
def combined_env(lenv, penv):
    if lenv and penv:
        env = lenv.copy()
        env.update(penv)
    else:
        env = lenv or penv
    return env
def git_clone(url, dest):
    return run_git(['clone', url, dest])
def hg_clone(url, dest):
    return run_hg(['clone', url, dest])
def git_checkout(commit):
    return run_git(['checkout', commit])
def hg_update(commit):
    return run_hg(['update', commit])
def git_status():
    return run_git(['status'])
def hg_summary():
    return run_hg(['summary'])
def git_show():
    template = (r'# C&O commit: %H%n'
                r'# C&O commit ref names: %D%n'
                r'# C&O commit date: %ai%n'
                r'# C&O commit author: %aN%n'
                r'# C&O commit message: %s%n')
    return run_git(['show', '-q', '--format=format:' + template], silent=True)
def hg_log():
    template = (r'# C&O commit: {rev}:{node}\n'
                r'# C&O commit branch: {branch}\n'
                r'# C&O commit date: {date|isodatesec}\n'
                r'# C&O commit author: {author|person}\n'
                r'# C&O commit message: {desc|firstline}\n')
    return run_hg(['log', '-r', '.', '-T', template], silent=True)
def git_files(include, exclude):
    cmd = ['ls-files']
    cmd.extend(include)
    files = run_git(cmd, silent=True, get_output=True)
    if files is not False:
        files = files.splitlines()
        for e in exclude:
            files = [f for f in files if not fnmatchcase(f, e)]
    return files
def hg_files(include, exclude):
    cmd = ['files']
    for pat in include:
        cmd.extend(('-I', pat))
    for pat in exclude:
        cmd.extend(('-X', pat))
    files = run_hg(cmd, silent=True, get_output=True, ignore_codes=(1,))
    if files is not False:
        files = files.splitlines()
    return files
def execute(tmp, config, args):
    if not prevalidate(config):
        return False
    os.chdir(tmp)
    source = './source'
    print('# C&O task: clone')
    print('# C&O project URL: {}'.format(config['url']))
    if config['scm'] == 'git':
        if not git_clone(config['url'], source):
            return False
    elif config['scm'] == 'hg':
        if not hg_clone(config['url'], source):
            return False
    print('$ cd {}'.format(source))
    os.chdir(source)
    if args.commit is not None:
        if config['scm'] == 'git':
            if not git_checkout(args.commit):
                return False
        elif config['scm'] == 'hg':
            if not hg_update(args.commit):
                return False
    if config['scm'] == 'git':
        if not git_status():
            return False
    elif config['scm'] == 'hg':
        if not hg_summary():
            return False
    if config['scm'] == 'git':
        if not git_show():
            return False
    elif config['scm'] == 'hg':
        if not hg_log():
            return False
    print('# C&O task: setup')
    linters = []
    distinct = []
    for linter in config.get('linters', []):
        if 'name' not in linter:
            print("# C&O skipping linter without 'name': {}".format(linter))
            continue
        name = linter['name']
        if 'include' not in linter:
            print("# C&O skipping '{}': no 'include' in config".format(name))
            continue
        linters.append(linter)
        if name not in distinct:
            distinct.append(name)
    print('# C&O linters requested: {}'.format(' '.join(distinct)))
    linter_config = {}
    for linter in linters:
        name = linter['name']
        if name in linter_config:
            continue
        lc = read_linter_config(name)
        if lc is None:
            print("# C&O skipping '{}': no config".format(name))
            continue
        if 'exec' not in lc:
            print("# C&O skipping '{}': no 'exec' in config".format(name))
            continue
        linter_config[name] = lc
        for item in lc.get('setup', []):
            if not run(item):
                return False
        if 'version' in lc:
            env = combined_env(lc.get('env'), linter.get('env'))
            if not run(lc['exec'] + lc['version'], env=env):
                return False
    print('# C&O linters installed: {}'.format(' '.join(linter_config.keys())))
    print('# C&O task: checks')
    for linter in linters:
        if linter['name'] not in linter_config:
            continue
        if config['scm'] == 'git':
            files = git_files(linter['include'], linter.get('exclude', []))
        elif config['scm'] == 'hg':
            files = hg_files(linter['include'], linter.get('exclude', []))
        if files is False:
            return False
        lc = linter_config[linter['name']]
        for f in files:
            cmd = lc['exec']
            flags = lc.get('flags', []) + linter.get('flags', [])
            pf = lc.get('post_flags', []) + linter.get('post_flags', [])
            codes = lc.get('codes', (1,))
            env = combined_env(lc.get('env'), linter.get('env'))
            if not run(cmd + flags + [f] + pf, ignore_codes=codes, env=env):
                return False
    return True
def wrapper(config, args):
    print('# C&O job started: {}'.format(timestamp()))
    tmp = mkdtemp(prefix='candolint.')
    if not execute(tmp, config, args):
        print('# C&O job failed')
    print('# C&O task: cleanup')
    rmtree(tmp)
    print('# C&O job finished: {}'.format(timestamp()))
def bad_exit():
    print('# C&O job failed (exception not caught)')
    print('# C&O job finished: {}'.format(timestamp()))
def main():
    parser = ArgumentParser()
    parser.add_argument(
        'config', type=FileType('r'),
        help='project configuration file (YAML)')
    parser.add_argument('commit', nargs='?', help='commit to update to')
    args = parser.parse_args()
    config = yaml.safe_load(args.config)
    try:
        wrapper(config, args)
    except:
        bad_exit()
        raise
if __name__ == '__main__':
    main()