#!/usr/bin/python3

# SPDX-License-Identifier: GPL-2.0-or-later
#
# Copyright (C) 2019-2021  Patryk Obara <patryk.obara@gmail.com>

"""
This script prints a summary snippet of information out of reports
created by scan-build or analyze-build for Clang's static code
analysis.

It returns success to the shell if the number or bugs encountered
is less than or equal to the desired maximum bugs. See --help
for a description of how to set the maximum.

If the count exceeds the maximum then the script will return a
status of 1 (failure), otherwise the script returns 0 (success).

"""
# This script depends on BeautifulSoup module, if you're distribution is
# missing it, you can use pipenv to install it for virtualenv spanning only
# this repo: pipenv install beautifulsoup4 html5lib

# pylint: disable=invalid-name
# pylint: disable=missing-docstring

import os
import argparse
import sys

from bs4 import BeautifulSoup

def summary_values(summary_table):
    if not summary_table:
        return
    for row in summary_table.find_all('tr'):
        description = row.find('td', 'SUMM_DESC')
        value = row.find('td', 'Q')
        if description is None or value is None:
            continue
        yield description.get_text(), int(value.get_text())


def read_soup(index_html):
    with open(index_html, encoding='utf-8') as index:
        soup = BeautifulSoup(index, 'html5lib')
        tables = soup.find_all('table')
        summary = tables[1]
        return dict(summary_values(summary))


def find_longest_name_length(names):
    return max(len(x) for x in names)


def print_summary(issues):
    summary = list(issues.items())
    size = find_longest_name_length(issues.keys()) + 1
    for warning, count in sorted(summary, key=lambda x: -x[1]):
        print('  {text:{field_size}s}: {count}'.format(
            text=warning, count=count, field_size=size))
    print()

def to_int(value):
    return int(value) if value is not None else None

def parse_args():
    parser = argparse.ArgumentParser(
        formatter_class=argparse.RawTextHelpFormatter, description=__doc__)

    parser.add_argument(
        'report',
        metavar='REPORT',
        help=("Path to the HTML report file"))

    max_bugs = to_int(os.getenv('MAX_BUGS', None))
    parser.add_argument(
        '-m', '--max-bugs',
        type=int,
        required=not isinstance(max_bugs, int),
        default=max_bugs,
        help='Defines the maximum number of bugs permitted to exist\n'
             'in the report before returning a failure to the shell.\n'
             'If not provided, the script will attempt to read it from\n'
             'the MAX_BUGS environment variable, which is currently\n'
             'set to: {}.  If a maximum of -1 is set then success is\n'
             'always returned to the shell.\n\n'.format(str(max_bugs)))

    return parser.parse_args()

def main():
    rcode = 0
    args = parse_args()
    bug_types = read_soup(args.report)
    total = bug_types.pop('All Bugs')
    if bug_types:
        print("Bugs grouped by type:\n")
        print_summary(bug_types)

    print('Total: {} bugs'.format(total), end='')
    if args.max_bugs >= 0:
        print(' (out of {} allowed)\n'.format(args.max_bugs))
        if total > args.max_bugs:
            print('Error: upper limit of allowed bugs is', args.max_bugs)
            rcode = 1
    else:
        print('\n')

    return rcode

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