//            Copyright Keysight Technologies 2012-2025
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading;
using System.Xml.Linq;

namespace OpenTap.Translation;

internal interface ITranslationProvider
{
    DisplayAttribute GetDisplayAttribute(IReflectionData mem);
    DisplayAttribute GetDisplayAttribute(Enum e, string name);
    string GetString(string key);
}

internal class ResXTranslationProvider : ITranslationProvider, IDisposable
{
    private TapThread _updateThread = null; 
    private readonly object StartUpdateThreadLock = new();
    void MaybeStartUpdateThread()
    {
        if (_updateThread != null) return;
        lock (StartUpdateThreadLock)
        {
            // If we got the lock after the update thread was initialized, we shouldn't initialie it again
            if (_updateThread != null) return;
            
            // If we are starting the update thread for the first time, we should block while initializing translations.
            UpdateInvalidatedMappings();
            
            TapThread.WithNewContext(() =>
            {
                _updateThread = TapThread.Start(() =>
                {
                    while (!TapThread.Current.AbortToken.IsCancellationRequested)
                    {
                        try
                        {
                            Thread.Sleep(TimeSpan.FromSeconds(5));
                            UpdateInvalidatedMappings();
                        }
                        catch
                        {
                            // we don't need to handle exceptions here, but we should ensure the update thread doesn't die
                        }
                    }
                });
            });
        }
    }

    public void Dispose()
    {
        _updateThread?.Abort();
    }

    public CultureInfo Culture { get; }
    private readonly Dictionary<string, string> CacheFileInvalidationTable = [];
    public ResXTranslationProvider(CultureInfo culture, IEnumerable<string> files)
    {
        Culture = culture;
        foreach (var file in files)
        {
            // Set the initial invalidation key for all files
            CacheFileInvalidationTable[file] = string.Empty;
        }
    }

    static string AttributeValue(XElement x, string name) => x.Attributes(name).FirstOrDefault()?.Value;
    static string ElementValue(XElement x, string name) => x.Elements(name).FirstOrDefault()?.Value;

    DisplayAttribute ComputeDisplayAttribute(string key, DisplayAttribute neutral)
    {
        bool translated = false;
        string name = neutral.Name;
        string description = neutral.Description;
        string group = string.Join(" \\ ", neutral.Group);
        double order = neutral.Order;

        if (GetString($"{key}.Name") is string tname)
        {
            name = tname;
            translated = true;
        }
        if (GetString($"{key}.Description") is string tdesc)
        {
            description = tdesc;
            translated = true;
        }
        if (GetString($"{key}.Group") is string tgroup)
        {
            group = tgroup;
            translated = true;
        }
        if (GetString($"{key}.Order") is string tord && double.TryParse(tord, out var o))
        {
            order = o;
            translated = true;
        }

        if (translated)
        {
            return new DisplayAttribute(Culture, name, description, group, order, neutral.Collapsed) { NeutralDisplayAttribute = neutral };
        }
        return neutral;
    }

    DisplayAttribute ComputeDisplayAttribute(Enum e, string name)
    {
        var enumType = e.GetType();
        var key = enumType.FullName + $".{name}";
        var fallback = enumType.GetMember(name).FirstOrDefault().GetDisplayAttribute();
        return ComputeDisplayAttribute(key, fallback);
    }

    DisplayAttribute ComputeDisplayAttribute(IReflectionData mem)
    {
        var key = mem switch
        {
            IMemberData imem => $"{imem.DeclaringType.Name}.{imem.Name}",
            // If the type is generic, the lookup key should not include the generic type parameter
            ITypeData td2 when td2.AsTypeData()?.Type is { } tp && tp.IsGenericType
                => TypeData.FromType(tp.GetGenericTypeDefinition()).Name,
            ITypeData tmem => tmem.Name,
            _ => mem.Name
        };

        var fallback = DefaultDisplayAttribute.GetUntranslatedDisplayAttribute(mem);
        return ComputeDisplayAttribute(key, fallback);
    }

    private ImmutableDictionary<IReflectionData, DisplayAttribute> _displayLookup = ImmutableDictionary<IReflectionData, DisplayAttribute>.Empty;
    private ImmutableDictionary<Enum, DisplayAttribute> _enumDisplayLookup = ImmutableDictionary<Enum, DisplayAttribute>.Empty;
    private ImmutableDictionary<string, string> _stringLookup = ImmutableDictionary<string, string>.Empty;

    private static readonly TraceSource log = Log.CreateSource("Translation");
    void UpdateInvalidatedMappings()
    {
        var newDict = new Dictionary<string, string>();
        foreach (var file in CacheFileInvalidationTable.Keys.ToArray())
        {
            var invalidationKey = GetCacheMarker(file);
            if (CacheFileInvalidationTable[file] != invalidationKey)
            {
                CacheFileInvalidationTable[file] = invalidationKey;
                try
                {
                    var resxDoc = XDocument.Load(file);

                    if (resxDoc.Root == null)
                        throw new Exception("Invalid XML");

                    foreach (var ele in resxDoc.Root.Elements("data"))
                    {
                        if (AttributeValue(ele, "name") is { } translationKey
                                && ElementValue(ele, "value") is { } translatedValue)
                        {
                            newDict[translationKey] = translatedValue;
                        }
                    }
                    log.Debug($"Reloaded translation file '{file}'.");
                }
                catch(Exception e)
                {
                    log.Error($"Unable to load translation resource file {file}.");
                    log.Debug(e);
                }
                _stringLookup = _stringLookup.SetItems(newDict);
                _displayLookup = ImmutableDictionary<IReflectionData, DisplayAttribute>.Empty;
                _enumDisplayLookup = ImmutableDictionary<Enum, DisplayAttribute>.Empty;
            }
        }

        static string GetCacheMarker(string file)
        {
            string key = string.Empty;
            if (File.Exists(file))
            {
                var fi = new FileInfo(file);
                key = $"{fi.LastWriteTimeUtc}.{fi.Length}";
            }
            return key;
        }
    }

    public DisplayAttribute GetDisplayAttribute(IReflectionData mem)
    {
        if (_displayLookup.TryGetValue(mem, out var disp)) return disp;
        disp = ComputeDisplayAttribute(mem);
        _displayLookup = _displayLookup.SetItem(mem, disp);
        return disp;
    }

    public DisplayAttribute GetDisplayAttribute(Enum e, string name)
    {
        if (_enumDisplayLookup.TryGetValue(e, out var disp)) return disp;
        disp = ComputeDisplayAttribute(e, name);
        _enumDisplayLookup = _enumDisplayLookup.SetItem(e, disp);
        return disp;
    }

    public string GetString(string key)
    {
        MaybeStartUpdateThread();
        return _stringLookup.TryGetValue(key, out var val) ? val : null;
    }
}