import ast
import json

from exceptions.skipIterationException import skipItertionException
from logger_module.package_logger import print_log
from flask import g
import traceback
from datetime import datetime, timedelta
from encrypt_decrypt import EncryptDecrypt
from key_resolver import KeyResolver
from operations import Operations


def execute_function(function_path, function_body, body, args=None):
    try:
        first_element = next(iter(function_body))
        # executes the built-in functions like encrypt, decrypt, upper
        if function_path in ['encrypt', 'decrypt']:
            if first_element:
                encrypted_value = getattr(EncryptDecrypt, function_path)(first_element)
                return encrypted_value
            return None
        if function_path == 'upper':
            resolved_value = KeyResolver().resolve_key(first_element, body)
            return str(resolved_value).upper()
        # replaces the args with the placeholders in the function block
        json_list = []
        if first_element.get('args') and args:
            for json_check in function_body[1:]:
                for idx, json_arguments in enumerate(first_element.get('args')):
                    temp_json = json.dumps(json_check).replace(json_arguments, str(args[idx]))
                    json_items = json.loads(temp_json)
                    json_list.append(json_items)
        else:
            json_list = function_body
        for steps in json_list:
            if steps.get('operation'):
                result = Operations.perform_operation(steps, body)
                if result and result != 1:
                    return result
            elif "conditions" in steps.keys():
                condition_result = condition_check(steps.get('conditions'), body)
                if steps.get(str(condition_result).lower()):
                    if isinstance(steps.get(str(condition_result).lower()), list):
                        nested_list = steps.get(str(condition_result).lower())
                        for list_item in nested_list:
                            if "conditions" in list_item.keys():
                                new_condition_result = condition_check(list_item.get('conditions'), body)
                                if list_item.get(str(new_condition_result).lower()):
                                    operation_item = list_item.get(str(new_condition_result).lower())
                                    new_list = operation_item if isinstance(operation_item, list) else [operation_item]
                                    for values in new_list:
                                        res = Operations.perform_operation(values, body)
                                        if res and res != 1:
                                            return res
                            else:
                                result = Operations.perform_operation(list_item, body)
                                if result and result != 1:
                                    return result
                    else:
                        result = Operations.perform_operation(steps.get(str(condition_result).lower()), body)
                        if result and result != 1:
                            return result
    except skipItertionException as ex:
        raise
    except Exception as ex:
        traceback.print_exc()


def condition_check(values, body):
    refined_values = []
    for element in values:
        refined_values.append(KeyResolver().resolve_key(element, body), )
    if 'notEquals' in values:
        if (refined_values[0] != refined_values[-1]) or (refined_values[0] == None or refined_values[-1] == None):
            return True
    if 'equals' in values:
        try:
            if refined_values[0] == values[-1] or refined_values[0] == refined_values[-1]:
                return True
        except Exception as ex:
            print_log(refined_values[0])
    elif 'isNotNull' in values:
        try:
            if refined_values[0]:
                return True
        except Exception as ex:
            print_log(values)
            print_log('Resolved values: ' + str(refined_values[0]))
    elif 'greaterThan' in values:
        if refined_values[0] is not None and refined_values[-1] is not None:
            if int(refined_values[0]) > int(refined_values[-1]):
                return True
    elif 'lesserThan' in values:
        if refined_values[0] is not None and refined_values[-1] is not None:
            if int(refined_values[0]) < int(refined_values[-1]):
                return True
    elif 'in' in values:
        if refined_values[0] is not None and refined_values[-1] is not None:
            if refined_values[0] in ast.literal_eval(refined_values[-1]):
                return True
    return False


def set_data(variable, data, value_return=False, column=None):
    try:
        if data and isinstance(data, list):
            # if not value_return:
            #     data = data[0]
            # else:
            setattr(g, variable, data)
            return 1
        if column:
            if len(column) == 1 and data:
                data = data.get(column[0])
        if not value_return:
            setattr(g, variable, data)
            return 1
        if value_return:
            return data
    except Exception as ex:
        print_log('variable = ' + variable)
        print_log(data)


def get_data(variable):
    return getattr(g, variable, None)


def resolve_date(value):
    if value.startswith("datetime.CUR_TIMESTAMP"):
        offset_str = value[len("datetime.CUR_TIMESTAMP"):]  # e.g. "+00:05:00" or ""
        now = datetime.today()

        if not offset_str:
            return now.strftime('%Y-%m-%d, %H:%M:%S')

        sign = offset_str[0]          # '+' or '-'
        h, m, s = map(int, offset_str[1:].split(":"))
        delta = timedelta(hours=h, minutes=m, seconds=s)

        return now + delta if sign == "+" else now - delta