#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from typing import Self, Any, Sequence, Optional
from Utils.Check import Check
from Utils.Patterns import RE

class Utils:

    @classmethod
    def get_keys(cls:type[Self], *items:list[Any|None]) -> list[str]:
        
        keys:list[str] = []
        item:Any|None

        for item in items:
            if Check.is_key(item):
                if item not in keys:
                    keys.append(item)
            elif Check.is_array(item):

                key:str

                for key in cls.get_keys(*item):
                    if key not in keys:
                        keys.append(key)

        return keys
    
    @classmethod
    def get_dictionaries(cls:type[Self], *items:list[Any|None]) -> list[dict[str, Any|None]]:
        
        dictionaries:list[dict[str, Any|None]] = []
        item:Any|None

        for item in items:
            if Check.is_dictionary:
                dictionaries.append(item)
            elif Check.is_array(item):

                dictionary:dict[str, Any|None]

                for dictionary in cls.get_dictionaries(*item):
                    dictionaries.append(dictionary)

        return dictionaries
    
    @classmethod
    def get_dictionary(cls:type[Self], inputs:Any|None, overwrite:bool = False) -> dict[str, Any|None]:

        dictionary:dict[str, Any|None] = {}

        if Check.is_dictionary(inputs):
            dictionary = inputs
        elif Check.is_array(inputs):

            key:str
            value:Any|None

            for key, value in cls.get_dictionary(inputs, overwrite).items():
                if overwrite or key not in dictionary:
                    dictionary[key] = value

        return dictionary
    
    @classmethod
    def get_values(cls:type[Self], 
        keys:str|Sequence[str], 
        inputs:dict[str, Any|None]|Sequence[Any|None], 
        default:Optional[Any] = None
    ) -> Any|None:
        if len(keys := cls.get_keys(keys)):

            dictionary:dict[str, Any|None]

            for dictionary in cls.get_dictionaries(inputs):

                key:str

                for key in keys:
                    if key in dictionary:
                        return dictionary[key]
        return default
    
    @classmethod
    def get_texts(cls:type[Self], *items:list[Any|None]) -> list[str]:
        
        texts:list[str] = []
        item:Any|None

        for item in items:
            if Check.is_string(item):
                texts.append(item)
            elif Check.is_array(item):

                text:str

                for text in cls.get_texts(*item):
                    texts.append(text)

        return texts
    
    @classmethod
    def string_variables(cls:type[Self], 
        string:str, 
        inputs:dict[str, Any|None]|Sequence[Any|None], 
        default:Optional[str|None] = None
    ) -> str:
        
        variables:dict[str, Any|None] = Utils.get_dictionary(inputs)

        def replace(match:Any) -> str:

            key:str = match.group(1)

            return str(
                variables[key] if key in variables and variables[key] is not None else 
                default if default is not None else 
            match.group(0))
        
        return RE.STRING_VARIABLES.sub(replace, string)