import re
from helpers.general_use import remap_transitional_territories

# sanity=re.compile(r"\{.+\}")

def clean_territories(str):
    return str.strip('{}').replace('\'','').replace(' ', '')

def transform_ownership(ownership, territory_list):



    # Init Vars
    ownership_list = {'owned': [], 'except': [], 'error': False}
    calc_ownership = []

    # This section handles the territory ownership
    if ownership is not None:
        ownership = str(ownership).split(';')
        ownership = [i.strip() for i in ownership]

        # Handle ownership
        for o in ownership:
            # Begin with straight string matches
            # WW
            if o == '100.00% Owned' or o == '100.00% Owned Everywhere':
                ownership_list['owned'].append(territory_list)

            # Conflicting Territories in Ownership
            elif '100.00% Owned Everywhere Except' in o:
                ownership_string = o.replace('100.00% Owned Everywhere Except', '').strip()
                ownership_list['except'].append(ownership_string.split(","))

            # Straight-forward ownership
            elif '100.00% Owned' in o:
                ownership_string = o.replace('100.00% Owned', '').strip()
                ownership_list['owned'].append(ownership_string.split(","))

            else:  # Try Regex - Change logic order for performance
                # Conflicting Territories in Ownership
                if 'Except' in o:
                    ownership_string = re.sub('(?<![\s\S])100\.00%\s*Owned\s*Everywhere\s*Except\s*', '', o).strip()
                    ownership_list['except'].append(ownership_string.split(","))
                # WW
                elif re.match('(?<![\s\S])100\.00%\s*Owned\s*(?![\s\S]+)', o) is not None \
                        or re.match('(?<![\s\S])100\.00%\s*Owned\s*Everywhere\s*(?![\s\S]+)', o) is not None:
                    ownership_list['owned'].append(['WW'])
                # Straight-forward ownership
                elif re.match('(?<![\s\S])100\.00%\s*Owned\s*(?=[\s\S]+)', o) is not None:
                    ownership_string = re.sub('(?<![\s\S])100\.00%\s*Owned\s*', '', o).strip()
                    ownership_list['owned'].append(ownership_string.split(","))
                else:
                    # Errors
                    ownership_list['error'] = True

    if ownership is None:
        calc_final = ''
    elif ownership_list['error']:
        calc_final = 'ERROR'
    else:  # collapse via union
        for key, val in ownership_list.items():
            if key == 'owned':
                for j in val:
                    calc_ownership = set(calc_ownership).union(set(j))
            if key == 'except':
                for j in val:
                    calc_ownership = set(calc_ownership)\
                        .union(set(territory_list)-set(j))

        if not False in [len(c) == 2 for c in calc_ownership]:
            calc_final = clean_territories(str(
                sorted(remap_transitional_territories(
                    calc_ownership))).strip('[]').replace(" ", ""))
        else:
            calc_final = None

    # if calc_final and (re.match(sanity, calc_final)
    #         or calc_final == ''
    #         or calc_final == 'ERROR'):
    return calc_final
    # else:
    #     return None


def transform_conflicts(conflicts, territory_list):
    # Init Vars
    conflict_list = {'conflicts': [], 'except': [], 'error': False}
    calc_conflicts = []

    # Handle conflicts
    if conflicts is not None:
        # WW
        if re.match('(?<![\s\S])Conflict\s*Everywhere\s*(?![\s\S]+)', conflicts) is not None:
            conflict_list['conflicts'].append(territory_list)

        # Conflicting Territories in Ownership
        elif 'Except' in conflicts:
            conflict_string = re.sub('(?<![\s\S])Conflict\s*Everywhere\s*Except\s*', '', conflicts).strip()
            conflict_list['except'].append(conflict_string.split(","))

        # Straight-forward ownership
        elif re.match('(?<![\s\S])Conflict\s*(?=[\s\S]+)', conflicts) is not None:
            conflict_string = re.sub('(?<![\s\S])Conflict\s*', '', conflicts).strip()
            conflict_list['conflicts'].append(conflict_string.split(","))
        else:  # Errors
            conflict_list['error'] = True

    if conflicts is None:
        calc_conflicts = ''
    elif conflict_list['error']:
        calc_conflicts = 'ERROR'
    else:  # collapse via union
        for key, val in conflict_list.items():
            if key == 'owned':
                for j in val:
                    calc_conflicts = set(calc_conflicts).union(
                        set(j))
            if key == 'except':
                for j in val:
                    calc_conflicts = set(calc_conflicts)\
                        .union(set(territory_list)-set(j))
        calc_conflicts = str(calc_conflicts)

    return calc_conflicts