import traceback
from flask import request
import uuid
import os

from logger_module.package_logger import print_log


class KeyResolver:

    def resolve_key(self, key, request_body):
        try:
            if str(key).isnumeric() or str(key) == '' or str(key) == '.':
                result = key
            elif isinstance(key, bool):
                result = str(key)
            elif key == "request_id":
                result = str(uuid.uuid4())
            elif 'datetime' in str(key):
                from helper_functions import resolve_date
                result = resolve_date(key)
            elif str(key).startswith('components->'):
                from components import Components
                split_param = str(key).split("->")
                function_name = split_param[1]
                # components.py expects the raw comma-separated string as the first tuple argument
                args = (split_param[2],)
                result = Components.execute_component(function_name, args)
            else:
                plus_split = [key]
                result = ''
                for items in plus_split:
                    iter_result = self.get_key_value(items, request_body)
                    if isinstance(iter_result, str):
                        result += iter_result
                    else:
                        result = iter_result
            return result
        except Exception as ex:
            print(key)
            traceback.print_exc()

    def get_key_value(self, key, body):
        """
        Resolves and fetches the key value from env, auth, request
        :param key: key to be fetched
        :param body: request body to fetch the data
        :return: resolved value of the key
        """
        try:
            from helper_functions import get_data
            result_value = key
            if '$env' in key.split('.'):
                result_value = self.get_env_value(key)
            elif '$auth' in key.split('.'):
                result_value = self.get_auth_value(key.strip('auth.'))
            elif '$token' in key.split('.'):
                result_value = self.get_token_payload(key.strip('$token.'))
            elif '->' in str(key):
                split_elem = key.split('->')
                function_name = split_elem[0]
                args = ()
                for item in split_elem[1:]:
                    args = args + (item,)
                from components import Components
                result_value = Components.execute_component(function_name, args)
            elif '$request' in key.split('.'):
                key = key.replace('$request.', '')
                key_split = key.split('.')
                for item in key_split:
                    if '[' in item:
                        idx = item.index('[')
                        first_item = item[:idx]
                        n = item[idx + 1]
                        result_value = body.get(first_item)[int(n)] if len(body.get(first_item)) > int(n) else None
                    elif item == '$request':
                        result_value = body
                    else:
                        result_value = body.get(item) if body else None
                    body = result_value
            elif '$' in key:
                key = key.replace('$', '')
                if '.' in key:
                    split_key = key.split('.')
                    result_value = get_data(split_key[0])
                    for k in split_key[1:]:
                        try:
                            result_value = result_value.get(k)
                        except AttributeError as ex:
                            print_log(k)
                else:
                    result_value = get_data(key)
            return result_value
        except Exception as ex:
            print_log(key)

    def get_env_value(self, key):
        """
        Fetch the value from environment variable
        :param key: key present in env
        :return: resolved value
        """
        key = key.replace('$env.', '')
        result = os.getenv(key)
        return result

    def get_auth_value(self, key):
        """
        Fetch the auth value from the request headers
        :param key: key to be fetched from auth header
        :return: resolved auth header value
        """
        result = request.headers.get(key.replace('$auth.', ''))
        return str(result)

    def get_token_payload(self, key):
        """
        Fetch the value for key from the token payload
        :param key: key to be fetched from auth header
        :return: value of token payload for the respective key
        """
        from helper_functions import get_data
        payload = get_data('token')
        result = payload.get(key)
        return str(result)