"""Handy general use functions."""
from collections import Counter
from distutils.util import strtobool
from itertools import zip_longest
import json
import os


def zip_dict(keys, values):
    """Return a dict of two lists."""
    return dict(zip(keys, values))


def split_zip_dict(s1, s2):
    """Return a dict of two comma-separated strings."""
    keys = s1.split(',')
    values = s2.split(',')

    return zip_dict(keys, values)


def var_to_bool(s):
    """Convert various variable types to bool."""
    if type(s) is bool:
        return s

    if (type(s) is not str and type(s) is not int) or s is None:
        raise ValueError('Cannot covert {} to a bool'.format(s))
    else:
        if (type(s) is int and int(s) == 0) or not strtobool(s):
            return_var = False
        elif (type(s) is int and int(s) == 1) or strtobool(s):
            return_var = True
        else:
            raise ValueError('Cannot covert {} to a bool'.format(s))

    return return_var


def primitive_dict(obj):
    """Create a dict from an iterable."""
    return {
        f: k for f, k in vars(obj).items()
        if ((type(k) is str or type(k) is int or type(k) is bool or type(
            k) is list or type(k) is dict or type(k) is set or type(
            k) is float or type(k) is None) and '__' not in f[:2])}


def grouper(iterable, n, fillvalue=None):
    """Collect data into fixed-length list_chunks or blocks."""
    # grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx"
    args = [iter(iterable)] * n
    return zip_longest(*args, fillvalue=fillvalue)


def list_chunks(l, n):
    """Yield successive n-sized list_chunks from l."""
    l2 = list(l)
    for i in range(0, len(l2), n):
        yield l2[i:i + n]


def dedupe_list(seq):  # OrderedDict is faster as of python 3.5
    """Dedupe a list while preserving order."""
    seen = set()
    seen_add = seen.add
    return [x for x in seq if not (x in seen or seen_add(x))]


# TODO: add args, etc. to docstring
def sanitize_json_dumps(s):
    """Perform an aggressive clean of a string json data."""
    try:
        clean_json = json.dumps(s, ensure_ascii=False)

        clean_json = repr(clean_json).replace('\\', '\\')[1:-1]

    except Exception as e:
        return json.dumps({'error': str(e)}, ensure_ascii=False)

    return clean_json


# TODO: add args, etc. to docstring
def merge_two_dicts(x, y):
    """Merge two dicts. 2nd overwrites first when keys match."""
    z = x.copy()  # start with x's keys and values
    z.update(y)  # modifies z with y's keys and values & returns None
    return z


# TODO: add args, etc. to docstring
def represents_int(s):
    """Check if a variable of unknown type can represent an int."""
    try:
        int(s)
        return True
    except ValueError:
        return False


def escape_bad_chars(s):
    """Escape characters which cause problems in str ingestion."""
    s = s.replace('\'', '\\\'')
    return s


def which(program):
    """Determines if an application is installed on the system."""

    def is_exe(file_path):
        return os.path.isfile(file_path) and os.access(file_path, os.X_OK)

    fpath, fname = os.path.split(program)
    if fpath:
        if is_exe(program):
            return program
    else:
        for path in os.environ["PATH"].split(os.pathsep):
            exe_file = os.path.join(path, program)
            if is_exe(exe_file):
                return exe_file

    return None


def check_for_dupes(elements):
    """Check if given list contains any duplicates """
    setOfElems = set()
    for elem in elements:
        if elem in setOfElems:
            return True
        else:
            setOfElems.add(elem)
    return False


# Slower Version of above
# def check_for_dupes(list):
#     """Find and report on duplicates."""
#     has_dupes = False
#     deduped_list = dedupe_list(list)
#
#     if len(list) != len(deduped_list):
#         has_dupes = True
#
#     return has_dupes


def get_duplicates_in_list(list):
    """Report the duplicates in a list of items"""

    # Using Counter in case of complex hashable objects.
    dupe_cnt = Counter()
    for x in list:
        dupe_cnt[x] += 1

    dupe_dict = dict()
    for dupe, cnt in dupe_cnt.items():
        if cnt > 1:
            dupe_dict[dupe] = cnt

    return dupe_dict


def compare_lists(list_1, list_2, case_sensitive=False):
    """Generates a dict report of the difference and intersection of two
    lists.

    Args:
        list_1: (list) a list of elements.
        list_2: (list) a second list of elements.
        case_sensitive: (bool) Determines if comparisons will be case
        sensitive.

    Returns:
        dict: A dictionary of comparisons, containing 3 lists,
        stored in the keys 'list_1_only', 'list_2_only', and 'both'
    """
    comparisons = dict()
    comparisons['list_1_only'] = list()
    comparisons['list_2_only'] = list()
    comparisons['both'] = list()

    list_1_orig = list_1.copy()
    list_2_orig = list_2.copy()

    if not case_sensitive:
        list_1 = [x.lower() for x in list_1]
        list_2 = [x.lower() for x in list_2]

    for pos, el in enumerate(list_1):
        if el in list_2:
            comparisons['both'].append(list_1_orig[pos])
        else:
            comparisons['list_1_only'].append(list_1_orig[pos])

    comparisons_both_orig = comparisons['both'].copy()

    if not case_sensitive:
        comparisons['both'] = [x.lower() for x in comparisons['both']]

    for pos, el in enumerate(list_2):
        if el not in comparisons['both']:
            comparisons['list_2_only'].append(list_2_orig[pos])

    comparisons['both'] = comparisons_both_orig

    return comparisons


def check_consecutive(elements):
    elements = [int(x) for x in elements]

    return sorted(elements) == list(range(min(elements), max(elements) + 1))