import sys
import os
import re
import random
import json

from pathlib import Path



def sort_by_key(arr, key):
    output = None
    if key in arr.keys():
        output = arr[key]

    if output == True:  output = 1
    if output == False: output = 0

    if output is not None:
        return output

    return 0


def mkdir(dir_path):
    path_object = Path(dir_path)
    path_object.mkdir(parents=True, exist_ok=True)

def touch(file_path, default_content=""):
    path_object = Path(file_path)
    path_object.parent.mkdir(parents=True, exist_ok=True)

    if not os.path.exists(file_path):
        with open(file_path, "w") as file_handle:
            file_handle.write(default_content)


def generate_token():
    character_set   = "0123456789abcdef"
    output_token    = ""
    for i in range(32):
        output_token = output_token + random.choice(character_set)
    return output_token


class JsonFile:
    def __init__(self, path, defaults={}):
        self.path       = path
        self.contents   = {}
        self.defaults   = defaults
        self.load()


    def load(self):
        touch(self.path, default_content="{}")

        with open(self.path) as f:
            f.seek(0)
            self.contents = json.loads(f.read())

        for k in self.defaults:
            if k not in self.contents.keys():
                self.contents[k] = self.defaults[k]

        self.save()


    def save(self):
        with open(self.path, "w") as f:
            f.write(json.dumps(self.contents, indent=4))


    def get(self, key, default_value=None, save=False):
        if key in self.contents.keys():
            return self.contents[key]
        else:
            if save:
                self.contents[key] = default_value
                self.save()
            return default_value


    def __getitem__(self, key):
        return self.get(key)


    def __setitem__(self, key, value):
        print(f"{self.path} setting {key} to {value}")
        self.contents[key] = value
        self.save()


    def keys(self):
        return self.contents.keys()


    def widget(self, st, kind, name, key, **kwargs):
        setting_key     = f"setting_{key}"
        value_to_render = self[key]

        def on_change_internal():
            val = st.session_state[setting_key]
            print(f"Set {key} to {val}")

            if kind == st.text_area:
                if "array_separator" in extra_options.keys():
                    sep = extra_options["array_separator"]
                    val = val.strip().split(sep)

            self.load()
            self[key] = val
            self.save()

            if "on_change" in kwargs:
                kwargs.get("on_change")()

        if kind == st.selectbox:
            options         = extra_options["options"]
            selected_index  = 0
            
            try:
                selected_index  = options.index(self[key])
            except:
                pass

            del extra_options["options"]

            kind(
                name,
                options=options,
                index=selected_index,
                key=setting_key,
                on_change=on_change_internal,
                **extra_options)

            return

        if kind == st.text_area:
            if "array_separator" in extra_options.keys():
                sep             = extra_options["array_separator"]
                value_to_render = sep.join(value_to_render)
                del extra_options["array_separator"]

        kind(name, value=value_to_render, key=setting_key, on_change=on_change_internal, **kwargs)

def get_next_filename(path):
    if not os.path.exists(path):
        return path

    extension_pat   = r"\.[A-Za-z0-9]{1,}$"
    extension       = ""
    without_ext     = path

    if re.search(extension_pat, path):
        extension   = re.findall(extension_pat, without_ext)[0]
        without_ext = re.sub(extension_pat, "", without_ext)

    number_pat  = r" [0-9]{1,}$"
    number      = 1

    if re.search(number_pat, without_ext):
        number      = re.findall(number_pat, without_ext)[0]
        without_ext = re.sub(number_pat, "", without_ext)

        number = int(number)
        number = number + 1

    without_ext = f"{without_ext} {number}"
    with_ext    = without_ext + extension

    return with_ext