using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using Newtonsoft.Json.Linq;
using System.Text.RegularExpressions;


namespace GTPCorrgir
{
    internal class Obsidean
    {
        static HashSet<string> technicalTerms;

        static string GetObsidianConfigPath()
        {
            string appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
            return Path.Combine(appDataPath, "obsidian", "obsidian.json");
        }
        
        static string GetVaultPath(string vaultName)
        {
            try
            {
                string pathToJsonFile = GetObsidianConfigPath();
                string jsonContent = File.ReadAllText(pathToJsonFile);
                JObject jsonObject = JObject.Parse(jsonContent);
                JObject vaults = (JObject)jsonObject["vaults"];

                foreach (var vault in vaults)
                {
                    // 'vault' es un KeyValuePair<string, JToken>
                    // 'vault.Key' es la clave (ID del vault), 'vault.Value' es el valor (detalles del vault como JToken)
                    string path = (string)vault.Value["path"];
                    if (!string.IsNullOrEmpty(path))
                    {
                        // Añadir una barra al final asegura que Path.GetDirectoryName funcione correctamente
                        string lastDirectoryName = Path.GetFileName(Path.GetDirectoryName(path.TrimEnd('\\') + "\\"));

                        if (lastDirectoryName.Equals(vaultName, StringComparison.OrdinalIgnoreCase))
                        {
                            return path;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error al leer o parsear el archivo JSON: " + ex.Message);
            }
            return null;
        }

        public void LeerPalabrasTecnicas()
        {
            // "C:\Users\migue\OneDrive\Miguel\Obsidean\Trabajo\VM\Palabras Tecnicas\Lista.md"
            string pathToMarkdown = GetVaultPath("VM");
            if (!string.IsNullOrEmpty(pathToMarkdown))
            {
                string pathToLista = pathToMarkdown + "\\Palabras Tecnicas\\Lista.md";
                string[] lines = File.ReadAllLines(pathToLista);
                technicalTerms = ExtractTechnicalTerms(lines);
            }

            // Ahora puedes usar technicalTerms para tu lógica de corrección
        }

        public HashSet<string> ExtractTechnicalTerms(string[] lines)
        {
            var terms = new HashSet<string>();
            foreach (var line in lines)
            {
                // Suponiendo que cada línea contiene un término técnico
                terms.Add(line.Trim());
            }
            return terms;
        }

        public string MarkTechnicalTerms(string text)
        {
            // Utilizar Regex para identificar palabras individualmente
            return Regex.Replace(text, @"\b(\w+)\b", match =>
            {
                string word = match.Groups[1].Value;
                // Verificar si la palabra está en el conjunto de términos técnicos
                if (technicalTerms.Contains(word))
                {
                    return $"[[{word}]]";  // Encerrar la palabra en corchetes si es técnica
                }
                return word;  // Devolver la palabra sin modificar si no es técnica
            });
        }

        public string MarkTechnicalTerms_IgnoreCase(string text)
        {
            // Utilizar Regex para identificar palabras individualmente, ignorando mayúsculas y minúsculas
            return Regex.Replace(text, @"\b(\w+)\b", match =>
            {
                string word = match.Groups[1].Value;
                // Verificar si la palabra está en el conjunto de términos técnicos, ignorando mayúsculas y minúsculas
                if (technicalTerms.Contains(word, StringComparer.OrdinalIgnoreCase))
                {
                    return $"[[{word}]]";  // Encerrar la palabra en corchetes si es técnica
                }
                return word;  // Devolver la palabra sin modificar si no es técnica
            }, RegexOptions.IgnoreCase);
        }

        public string RemoveTechnicalTermMarkers(string text)
        {
            // Utilizar Regex para encontrar y remover los dobles corchetes
            return Regex.Replace(text, @"\[\[(.*?)\]\]", match =>
            {
                string word = match.Groups[1].Value;
                // Verificar si la palabra está en el conjunto de términos técnicos, ignorando mayúsculas y minúsculas
                if (technicalTerms.Contains(word))
                {
                    return word;  // Devolver la palabra sin corchetes si es técnica
                }
                return match.Value;  // Devolver la palabra con corchetes si no es técnica
            });
        }


    }

}