# -*- coding: utf-8 -*-

import re
from bs4 import formatter, BeautifulSoup as bs
from pathlib import Path

xml_4indent_formatter = formatter.XMLFormatter(indent=4)
NEW_ATTRS = {'required', 'invisible', 'readonly', 'column_invisible'}
percent_d_regex = re.compile("%\('?\"?[\w\.\d_]+'?\"?\)d")

def get_files_recursive(path):
    return (str(p) for p in Path(path).glob('**/*.xml') if p.is_file())

root_dir = input('Enter root directory to check (empty for current directory) : ')
root_dir = root_dir or '.'
all_xml_files = get_files_recursive(root_dir)

def normalize_domain(domain):
    """Normalize Domain, taken from odoo/osv/expression.py -> just the part so that & operators are added where needed.
        After that, we can use a part of the def parse() from the same file to manage parenthesis for and/or"""
    if len(domain) == 1:
        return domain
    result = []
    expected = 1                            # expected number of expressions
    op_arity = {'!': 1, '&': 2, '|': 2}
    for token in domain:
        if expected == 0:                   # more than expected, like in [A, B]
            result[0:0] = ['&']             # put an extra '&' in front
            expected = 1
        if isinstance(token, (list, tuple)):  # domain term
            expected -= 1
            token = tuple(token)
        else:
            expected += op_arity.get(token, 0) - 1
        result.append(token)
    return result

def stringify_leaf(leaf):
    stringify = ''
    switcher = False
    # Replace operators not supported in python (=, like, ilike)
    operator = str(leaf[1])
    if operator == '=':
        operator = '=='
    elif 'like' in operator:
        if 'not' in operator:
            operator = 'not in'
        else:
            operator = 'in'
        switcher = True
    # Take left operand, never to add quotes (should be python object / field)
    left_operand = leaf[0]
    # Take care of right operand, don't add quotes if it's list/tuple/set/boolean/number, check if we have a true/false/1/0 string tho.
    right_operand = leaf[2]
    if right_operand in ('True', 'False', '1', '0') or type(right_operand) in (list, tuple, set, int, float, bool):
        right_operand = str(right_operand)
    else:
        right_operand = "'"+right_operand+"'"
    stringify = "%s %s %s" % (right_operand if switcher else left_operand, operator, left_operand if switcher else right_operand)
    return stringify

def stringify_attr(stack):
    if stack in (True, False, 'True', 'False', 1, 0, '1', '0'):
        return stack
    last_parenthesis_index = max(index for index, item in enumerate(stack[::-1]) if item not in ('|', '!'))
    stack = normalize_domain(stack)
    stack = stack[::-1]
    result = []
    for index, leaf_or_operator in enumerate(stack):
        if leaf_or_operator == '!':
            expr = result.pop()
            result.append('(not (%s))' % expr)
        elif leaf_or_operator == '&' or leaf_or_operator == '|':
            left = result.pop()
            # In case of a single | or single & , we expect that it's a tag that have an attribute AND a state
            # the state will be added as OR in states management
            try:
                right = result.pop()
            except IndexError:
                res = left + ('%s' % ' and' if leaf_or_operator=='&' else ' or')
                result.append(res)
                continue
            form = '(%s %s %s)'
            if index > last_parenthesis_index:
                form = '%s %s %s'
            result.append(form % (left, 'and' if leaf_or_operator=='&' else 'or', right))
        else:
            result.append(stringify_leaf(leaf_or_operator))
    result = result[0]
    return result

def get_new_attrs(attrs):
    new_attrs = {}
    attrs_dict = eval(attrs.strip())
    for attr in NEW_ATTRS:
        if attr in attrs_dict.keys():
            new_attrs[attr] = stringify_attr(attrs_dict[attr])
    ordered_attrs = {attr: new_attrs[attr] for attr in NEW_ATTRS if attr in new_attrs}
    return ordered_attrs

# Prettify puts <attribute> on three lines (1/ opening tag, 2/ text, 3/ closing tag), not very cool.
# Taken from https://stackoverflow.com/questions/55962146/remove-line-breaks-and-spaces-around-span-elements-with-python-regex
# And changed to avoid putting ALL one line, and only manage <attribute>, as it's the only one messing stuff here
# Kinda ugly to use the 3 types of tags but tbh I keep it like this while I have no time for a regex replace keeping the name="x" :p
def prettify_output(html):
    for attr in NEW_ATTRS:
        html = re.sub(f'<attribute name="{attr}">[ \n]+',f'<attribute name="{attr}">', html)
    html = re.sub(f'[ \n]+</attribute>',f'</attribute>', html)
    html = re.sub(r'<field name="([a-z_]+)">[ \n]+', r'<field name="\1">', html)
    html = re.sub(r'[ \n]+</field>', r'</field>', html)
    return html

autoreplace = input('Do you want to auto-replace attributes ? (y/n) (empty == no) (will not ask confirmation for each file) : ') or 'n'
nofilesfound = True
ok_files = []
nok_files = []

for xml_file in all_xml_files:
    try:
        with open(xml_file, 'rb') as f:
            contents = f.read().decode('utf-8')
            f.close()
            if not 'attrs' in contents and not 'states' in contents:
                continue
            counter_for_percent_d_replace = 1
            percent_d_results = {}
            for percent_d in percent_d_regex.findall(contents):
                contents = contents.replace(percent_d, "'REPLACEME%s'" % counter_for_percent_d_replace)
                percent_d_results[counter_for_percent_d_replace] = percent_d
                counter_for_percent_d_replace += 1
            soup = bs(contents, 'xml')
            tags_with_attrs = soup.select('[attrs]')
            attribute_tags_name_attrs = soup.select('attribute[name="attrs"]')
            tags_with_states = soup.select('[states]')
            attribute_tags_name_states = soup.select('attribute[name="states"]')
            if not (tags_with_attrs or attribute_tags_name_attrs or\
                    tags_with_states or attribute_tags_name_states):
                continue
            print('\n################################################################')
            print('##### Taking care of file -> %s' % xml_file)
            print('\n########### Current tags found ###\n')
            for t in tags_with_attrs + attribute_tags_name_attrs + tags_with_states + attribute_tags_name_states:
                print(t)

            nofilesfound = False
            # Management of tags that have attrs=""
            for tag in tags_with_attrs:
                attrs = tag['attrs']
                new_attrs = get_new_attrs(attrs)
                del tag['attrs']
                for new_attr in new_attrs.keys():
                    tag[new_attr] = new_attrs[new_attr]
            # Management of attributes name="attrs"
            attribute_tags_after = []
            for attribute_tag in attribute_tags_name_attrs:
                new_attrs = get_new_attrs(attribute_tag.text)
                for new_attr in new_attrs.keys():
                    new_tag = soup.new_tag('attribute')
                    new_tag['name'] = new_attr
                    new_tag.append(str(new_attrs[new_attr]))
                    attribute_tags_after.append(new_tag)
                    attribute_tag.insert_after(new_tag)
                attribute_tag.decompose()
            # Management ot tags that have states=""
            for state_tag in tags_with_states:
                base_invisible = ''
                if 'invisible' in state_tag.attrs and state_tag['invisible']:
                    base_invisible = state_tag['invisible']
                    if not (base_invisible.endswith('or') or base_invisible.endswith('and')):
                        base_invisible = base_invisible + ' or '
                    else:
                        base_invisible = base_invisible + ' '
                invisible_attr = "state not in [%s]" % ','.join(("'" + state.strip() + "'") for state in state_tag['states'].split(','))
                state_tag['invisible'] = base_invisible + invisible_attr
                del state_tag['states']
            # Management of attributes name="states"
            attribute_tags_states_after = []
            for attribute_tag_states in attribute_tags_name_states:
                states = attribute_tag_states.text
                existing_invisible_tag = False
                # I don't know why, looking for attribute[name="invisible"] does not work,
                # but if it exists, I can find it with findAll attribute -> loop to name="invisible"
                for tag in attribute_tag_states.parent.findAll('attribute'):
                    if tag['name'] == 'invisible':
                        existing_invisible_tag = tag
                        break
                if not existing_invisible_tag:
                    existing_invisible_tag = soup.new_tag('attribute')
                    existing_invisible_tag['name'] = 'invisible'
                if existing_invisible_tag.text:
                    states_to_add = 'state not in [%s]' % (
                        ','.join(("'" + state.strip() + "'") for state in states.split(','))
                    )
                    if existing_invisible_tag.text.endswith('or') or existing_invisible_tag.text.endswith('and'):
                        new_invisible_text = '%s %s' % (existing_invisible_tag.text, states_to_add)
                    else:
                        new_invisible_text = ' or '.join([existing_invisible_tag.text, states_to_add])
                else:
                    new_invisible_text = 'state not in [%s]' % (
                        ','.join(("'" + state.strip() + "'") for state in states.split(','))
                    )
                existing_invisible_tag.string = new_invisible_text
                attribute_tag_states.insert_after(existing_invisible_tag)
                attribute_tag_states.decompose()
                attribute_tags_states_after.append(existing_invisible_tag)
            
            print('\n########### Will be replaced by ###\n')
            for t in tags_with_attrs + attribute_tags_after + tags_with_states + attribute_tags_states_after:
                print(t)
            print('################################################################\n')
            if autoreplace.lower()[0] == 'n':
                confirm = input('Do you want to replace? (y/n) (empty == no) : ') or 'n'
            else:
                confirm = 'y'
            if confirm.lower()[0] == 'y':
                with open(xml_file, 'wb') as rf:
                    html = soup.prettify(formatter=xml_4indent_formatter)
                    html = prettify_output(html)
                    for percent_d_result in percent_d_results.keys():
                        html = html.replace("'REPLACEME%s'" % percent_d_result, percent_d_results[percent_d_result])
                    rf.write(html.encode('utf-8'))
                    ok_files.append(xml_file)
    except Exception as e:
        nok_files.append((xml_file, e))

print('\n################################################')
print('################## Run  Debug ##################')
print('################################################')

if nofilesfound:
    print('No XML Files with "attrs" or "states" found in dir " %s "' % root_dir)

print('Succeeded on files')
for file in ok_files:
    print(file)
if not ok_files:
    print('No files')
print('')
print('Failed on files')
for file in nok_files:
    print(file[0])
    print('Reason: ', file[1])
if not nok_files:
    print('No files')