<?php

    class WMarkDown{

        private static $default_settings = [
            "default_value" => null,
            "nulls" => true,
            "default_settings_files" => __DIR__ . "/../JSON/WMarkDown.settings.json"
        ];
        private static $extension_mime = [];
        private static $mime_extension = [];
        private $custom_settings = [];
        private $input;
        private $wmarkdown_root = __DIR__ . "/..";
        private $root = __DIR__ . "/..";
        private $documentation_path = null;
        private $html_files = [];
        private $html_base = '';
        private $public_path = __DIR__ . "/../Public";
        private $hashes = [];
        private $documentation_path_relative = null;
        private $hash_alphabet = null;
        private $data_created = [
            "files" => [],
            "directories" => []
        ];
        private $ignore_script_paths = [];
        public static $string_to_pattern_special = [
            "\n" => "n",
            "\r" => "r",
            "\t" => "t"
        ];

        private function get_value($name, $nulls){
            foreach([$this->input, $this->custom_settings, self::$default_settings] as $input)
                if($input && isset($input[$name]) && ($nulls || $input[$name] !== null))
                    return $input[$name];
            return $this->get_value("default_value");
        }

        private function default_value($default, $nulls){
            if($nulls || $default !== null)
                return $default;
            return $this->get_value("default_value");
        }

        public static function is_dictionary($value){
            return is_array($value) && array_values($value) != $value;
        }

        public function settings($names = null, $inputs = null, $default = null, $nulls = null){

            if(!is_bool($nulls))
                $nulls = $this->get_value("nulls", false);

            if(!$names)
                return $this->default_value($default, $nulls);

            if(!is_array($names))
                $names = [$names];

            foreach(array_merge($inputs ? (is_dictionary($inputs) ? [$inputs] : (is_array($inputs) ? $inputs : [])) : [], [$this->input, $this->custom_settings, self::$default_settings]) as $input)
                if(self::is_dictionary($input))
                    foreach($names as $name)
                        if($name && isset($input[$name]) && ($nulls || $input[$name] !== null))
                            return $input[$name];
            return $this->default_value($default, $nulls);
        }

        public static function string_variables($string, $variables = null, $default = null){
            return preg_replace_callback('/\{([^\{\}]+)\}/', function($values) use($variables, $default){
                if(!isset($values[1]) || !$values[1])
                    return $values[0];
                if($variables && is_array($variables) && isset($variables[$values[1]]))
                    return $variables[$values[1]];
                if($default !== null)
                    return $default;
                return $values[0];
            }, $string);
        }

        private static function remove_directory($path){
            return;

            if(file_exists($path)){
                if(is_dir($path)){
                    foreach(scandir($path) as $item){
                        if(is_dir($file = $path . "/" . $item))
                            self::remove_directory($file);
                        else
                            unlink($file);
                    };
                    rmdir($path);
                }else
                    unlink($path);
            };

        }

        private function remove_current_html_files(){

            if(!file_exists($files = $this->root . $this->settings("html_files")))
                return;

            $data = json_decode(file_get_contents($files), true);

            foreach($data["files"] as $file)
                if(file_exists($file))
                    unlink($file);
            foreach($data["directories"] as $directory)
                if(file_exists($directory))
                    self::remove_directory($directory);

        }

        public static function save_file($path, $content){

            $directory = preg_replace('/^(\/?(([^\/]+\/)*))?\/?[^\/]+$/', "$1", $path);

            if(!file_exists($directory))
                mkdir($directory, 0777, true);
            file_put_contents($path, $content);

        }

        private function create_html_files($path = ""){

            if(file_exists($absolute = $this->documentation_path . $path))
                foreach(scandir($absolute) as $file){
                    if(in_array($file, [".", ".."]))
                        continue;
                    if(is_dir($directory = $absolute . "/" . $file))
                        $this->create_html_files($this->data_created["directories"][] = $path . "/" . $file);
                    elseif(preg_match('/^(((?!\.w).)+)(\.w)?\.md$/', $file, $matches))
                        self::save_file(
                            $this->data_created["files"][] = $this->public_path . $path . "/" . $matches[1] . ".html",
                            self::string_variables($this->html_base, array_merge(WMarkDown\Modules::format($this, file_get_contents($absolute . "/" . $file))))
                        );
                };

        }

        private function request($parameters){

            header("content-type: application/json");
            echo json_encode([
                "ok" => true,
                "code" => 200,
                "content" => null
            ]);

        }

        public function get_ignore_file_paths(){return array_merge([], $this->ignore_script_paths);}

        public function __construct($input = null){

            if(is_array($input))
                $this->input = $input;

            foreach(["default_settings_files", "settings_files"] as $name)
                if($files = $this->settings($name))
                    foreach(is_array($files) ? $files : [$files] as $path)
                        if($path && file_exists($path) && ($data = file_get_contents($path)) && ($json = @json_decode($data, true)))
                            foreach($json as $key => $value)
                                $this->custom_settings[$key] = $value;

            $post_key = $this->settings("variable_name");

            if(isset($_POST[$post_key])){
                $this->request(json_decode(base64_decode($_POST[$post_key]), true));
                return;
            };

            $this->wmarkdown_root = $this->settings("root");
            $this->root = $this->settings("root");
            $this->documentation_path_relative = $this->settings("documentation_path");
            $this->documentation_path = $this->root . $this->documentation_path_relative;
            $this->public_path = $this->root . $this->settings("public_path");
            $this->hash_alphabet = $this->settings("hash_alphabet");

            foreach($this->settings("ignore_script_paths") ?? [] as $path)
                $this->ignore_script_paths[] = $path;

            switch($this->settings("action")){
                case "update_scripts":
                    (new \WMarkDown\ScriptsAnalyzer($this))->update_files();
                break;
                case "build_html":
                default:
                    $this->hash_alphabet = str_split(preg_replace('/[^a-z\d_]/i', "", is_array($this->hash_alphabet) ? implode("", $this->hash_alphabet) : $this->hash_alphabet));

                    if(file_exists($html_base_path = $this->settings("html_base")))
                        $this->html_base = file_get_contents($html_base_path);

                    // $this->remove_current_html_files();
                    $this->create_html_files();
                    // print_r([$this->root . $this->settings("html_files"), $this->data_created]);
                    $this->save_file($this->root . $this->settings("html_files"), json_encode($this->data_created));
                break;
            };

        }

        public function get_root(){return "" . $this->root;}
        public function get_wmarkdown_root(){return "" . $this->wmarkdown_root;}

        public function get_hash(){

            $hash;
            $l = count($this->hash_alphabet) - 1;
            $length = $this->settings("hash_length");

            do{
                $hash = "";
                while(strlen($hash .= $this->hash_alphabet[rand(0, $l)]) < $length);
            }while(
                in_array($hash, $this->hashes) ||
                preg_match('/^\d/', $hash)
            );
            $this->hashes[] = $hash;

            return $hash;
        }

        public function load_file($path){
            foreach(["", $this->root, $this->wmarkdown_root] as $root)
                if(file_exists($file = $root . $path) && !is_dir($file))
                    return file_get_contents($file);
            return null;
        }

        public function get_documentation_path(){return "" . $this->documentation_path_relative;}

        public function get_mime($path){
            if(!$path || !preg_match('/^.+\.([^\.\/]+)$/', $path, $matches))
                return $this->settings("default_mime");

            $extension = $matches[1];

            if(empty(self::$extension_mime))
                self::$extension_mime = json_decode($this->load_file($this->settings("extension_mime_file")), true);

            if(isset(self::$extension_mime[$extension]))
                return self::$extension_mime[$extension];
            return $this->settings("default_mime");
        }

        public function get_extensions($mime){
            if(!$mime)
                return $this->settings("default_extension");

            if(empty(self::$mime_extension))
                self::$mime_extension = json_decode($this->load($this->settings("mime_extension_file")), true);

            if(isset(self::$mime_extension[$mime]))
                return self::$mime_extension[$mime];
            return $this->settings("default_extension");
        }

        public static function string_to_pattern($string){
            return preg_replace_callback('/[\r\n\t\.\-\:\{\[\(\)\]\}\#\@\|\!\?\*\+\^\\\\\/\&\%\~]/', function($values){
                return "\\" . (isset(\WMarkDown::$string_to_pattern_special[$values[0]]) ? \WMarkDown::$string_to_pattern_special[$values[0]] : $values);
            });
        }

    };