//            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.ComponentModel;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Threading;
using OpenTap.Cli;
using OpenTap.Package;
using OpenTap.Translation;

namespace OpenTap.Sdk.New;

/// <summary>
/// This class contains helpful utilities for creating translations of packages.
/// </summary>
[Display("translate", Group: "sdk", Description: "Create a new translation template for a package.")]
public class TranslateAction : ICliAction
{
    /// <summary>
    /// The packages to translate
    /// </summary>
    [UnnamedCommandLineArgument(nameof(Package), Description = "The package to translate.")]
    [Display("Package", "The packages to translate")]
    public string Package { get; set; }

    private static readonly TraceSource log = Log.CreateSource("Translate");

    /// <inheritdoc/>
    public int Execute(CancellationToken cancellationToken)
    {
        // Ensure translations are generated for the default language (english)
        using var session = Session.Create(SessionOptions.OverlayComponentSettings);
        EngineSettings.Current.Language = CultureInfo.InvariantCulture;

        var install = Installation.Current;
        if (string.IsNullOrWhiteSpace(Package))
        {
            log.Error($"Please specify a package name.");
            return 1;
        }
        var pkg = install.FindPackage(Package);
        if (pkg == null)
        {
            log.Error($"Package '{Package}' is not installed.");
            return 1;
        }

        var outputdir = TranslationManager.TranslationDirectory;
        var outputFileName = Path.Combine(outputdir, pkg.Name + ".resx");
        if (!Directory.Exists(outputdir))
            Directory.CreateDirectory(outputdir);

        var types = new List<ITypeData>();
        // first add all plugins
        types.AddRange(TypeData.GetDerivedTypes<ITapPlugin>());
        
        types = [.. types.Distinct()];

        static void recursivelyAddReferencedTypes(ITypeData td, HashSet<ITypeData> seen)
        {
            try
            {
                foreach (var mem in td.GetMembers())
                {
                    // These types would be filtered out later anyway, but let's just not even consider them
                    if (mem.TypeDescriptor.Name.StartsWith("System.")
                        || mem.TypeDescriptor.Name.StartsWith("Microsoft."))
                        continue;
                    if (SkipMem(td, mem))
                    {
                        continue;
                    }
                    // Always translate the member type if it is embedded.
                    if (mem.HasAttribute<EmbedPropertiesAttribute>() || SkipType(mem.TypeDescriptor) == false)
                    {
                        if (seen.Add(mem.TypeDescriptor))
                        {
                            recursivelyAddReferencedTypes(mem.TypeDescriptor, seen);
                        }
                    }
                }
            }
            catch
            {
                // This happens if a typedata implementation throws in GetMembers()
                // We cannot really do anything about this
            }
        }

        var seen = new HashSet<ITypeData>(types);
        foreach (var td in types)
        {
            recursivelyAddReferencedTypes(td, seen);
        }

        types = [.. seen];

        {
            // We are not interested in creating a different translation for each 
            // variant of a generic type we use. 
            // Remove all instances of generic types, and add a single reference to the generic variant.
            HashSet<TypeData> add = [];
            HashSet<TypeData> remove = [];
            foreach (var type in types)
            {
                if (AsTypeData(type) is { } td && td.Type.IsGenericType)
                {
                    remove.Add(td);
                    var gen = TypeData.FromType(td.Type.GetGenericTypeDefinition());
                    add.Add(gen);
                }
            }
            types.RemoveAll(remove.Contains);
            types.AddRange(add);
        }

        static string normalizePath(string path) => path.Replace('\\', '/');
        var typesSources = types.Select(x => Path.GetFullPath(TypeData.GetTypeDataSource(x).Location))
            .Where(x => x.StartsWith(install.Directory, StringComparison.OrdinalIgnoreCase))
            .Select(x => x.Substring(install.Directory.Length + 1))
            .Select(normalizePath)
            .ToArray();

        var outdir = Path.GetDirectoryName(outputFileName);
        if (!string.IsNullOrWhiteSpace(outdir))
            Directory.CreateDirectory(outdir);

        var writer = new ResXWriter(outputFileName);
        var packageFiles = new HashSet<string>(pkg.Files.Select(x => normalizePath(x.FileName)), StringComparer.OrdinalIgnoreCase);
        List<ITypeData> packageTypes = [];
        for (int i = 0; i < typesSources.Length; i++)
        {
            if (typesSources[i] == null) continue;
            if (packageFiles.Contains(typesSources[i]))
            {
                packageTypes.Add(types[i]);
            }
        }

        if (!packageTypes.Any())
        { 
            log.Error($"0 types discovered for package '{Package}'. This is likely a bug.");
            return 1;
        }
        
        foreach (var type in packageTypes)
        {
            if (SkipType(type))
                continue;

            if (type.DescendsTo(typeof(Enum)) && AsTypeData(type)?.Type is Type enumType)
            {
                // Special handling for enums. We need to write each enum variant
                WriteEnumMembers(writer, enumType);
                continue;
            }

            if (type.DescendsTo(typeof(IStringLocalizer)) && type.CanCreateInstance && type.CreateInstance() is IStringLocalizer t)
            {
                WriteStringLocalizerStrings(writer, t);
            }

            var members = GetMembers(type);
            var typeDisplay = type.GetDisplayAttribute();

            WriteAttribute(writer, type.Name, typeDisplay);
            foreach (var mem in members)
            {
                if (SkipMem(type, mem))
                    continue;
                var memDisplay = mem.GetDisplayAttribute();
                WriteAttribute(writer, $"{type.Name}.{mem.Name}", memDisplay);
            }
        }
        
        // Also add all display attributes defined in the plugin
        {
            var assemblyFiles = pkg.Files.Where(f => !f.FileName.StartsWith("Dependencies/")).Where(x =>
                    x.FileName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase) ||
                    x.FileName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
                .ToArray();
            List<Assembly> assemblies = [];
            foreach (var f in assemblyFiles)
            {
                try
                {
                    var asm = Assembly.LoadFrom(f.FileName);
                    assemblies.Add(asm);
                }
                catch
                {
                    // ignore
                }
            }

            foreach (var asm in assemblies)
            {
                foreach (var type in asm.ExportedTypes)
                {
                    if (type.GetCustomAttribute<DisplayAttribute>() is { } typeDisplay)
                    {
                        WriteAttribute(writer, type.FullName, typeDisplay);
                    }

                    foreach (var mem in type.GetMembers())
                    {
                        // Inherited members should be translated on the base type. Otherwise translators would
                        // have to duplicate translation of inherited members.
                        if (mem.DeclaringType != type) continue;
                        if (mem.GetCustomAttribute<DisplayAttribute>() is { } memDisplay)
                        {
                            WriteAttribute(writer, $"{type.FullName}.{mem.Name}", memDisplay);
                        }
                    }
                }
            }
        }
        
        writer.Generate();
        log.Info($"Created translation template file at {outputFileName}");

        return 0;
    }

    private static TypeData AsTypeData(ITypeData type)
    {
        do
        {
            if (type is TypeData td)
                return td;
            type = type?.BaseType;
        } while (type != null);
        return null;
    }

    private static void WriteEnumMembers(ResXWriter writer, Type enumType)
    {
        var names = Enum.GetNames(enumType);
        foreach (var name in names)
        {
            MemberInfo type = enumType.GetMember(name).FirstOrDefault();
            DisplayAttribute attr = type.GetCustomAttribute<DisplayAttribute>();
            attr ??= new DisplayAttribute(type.Name, null, Order: -10000, Collapsed: false);
            WriteAttribute(writer, $"{enumType.FullName}.{name}", attr);
        }
    }

    private static void WriteStringLocalizerStrings(ResXWriter writer, IStringLocalizer obj)
    {
        var t = obj.GetType();
        HashSet<string> added = [];
        Func<IStringLocalizer, string, string, CultureInfo, string> hook = (localizer, neutral, key, language) =>
        {
            var fullkey = $"{t.FullName}.{key}";
            if (added.Add(fullkey))
                writer.AddResource(fullkey, neutral);
            return neutral;
        };
        // inject hook
        var mgr = typeof(TranslationManager);
        mgr.GetField("TranslateFunction", BindingFlags.Static | BindingFlags.NonPublic)?.SetValue(null, hook);

        // we need to call the property getter for all properties to trigger all calls to Translate()
        foreach (var prop in t.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static))
        {
            if (prop.PropertyType != typeof(string) && prop.PropertyType != typeof(FormatString)) continue;
            try
            {
                object owner = prop.GetGetMethod().IsStatic ? null : obj;
                prop.GetValue(owner);
            }
            catch
            {
                // ignore
            }
        }
    }

    private static void WriteAttribute(ResXWriter writer, string prefix, DisplayAttribute disp)
    {
        writer.AddResource($"{prefix}.Name", disp.Name ?? "");
        if (!string.IsNullOrWhiteSpace(disp.Description))
            writer.AddResource($"{prefix}.Description", disp.Description ?? "");
        if (disp.Order != DisplayAttribute.DefaultOrder)
        {
            writer.AddResource($"{prefix}.Order", disp.Order);
        }

        if (disp.Group.Length > 0)
        {
            writer.AddResource($"{prefix}.Group", string.Join(" \\ ", disp.Group));
        }
    }

    static bool SkipType(ITypeData type)
    {
        try
        {
            if (type.DescendsTo(typeof(IStringLocalizer)))
            {
                if (type.CanCreateInstance) return false;
                // Skip abstract types with no error
                if (AsTypeData(type)?.Type?.IsAbstract == true) return true;
                // It is currently a requirement that IStringLocalizer can be instantiated.
                // In the future, we can improve the string detection algorithm to relax this requirement,
                // but for now we should warn the user that this will not work.
                log.Error($"String localizer '{type.Name}' does not have an empty constructor, and will not be translated.");
                return true;
            }

            return false;
        }
        catch (Exception ex)
        {
            // ignore. This can happen for bad typedata implementations. We should just ignore the type in this case
            // since we can't translate it if we can't enumerate the members.
            log.Error($"Error reflecting type '{type.Name}'. This type will not be translated.");
            log.Debug(ex);
        } 
        return true;
    }

    static IMemberData[] GetMembers(ITypeData type)
    {
        try
        {
            return type.GetMembers().ToArray();
        }
        catch (Exception ex)
        {
            // ignore. This can happen for bad typedata implementations. We should just ignore the type in this case
            // since we can't translate it if we can't enumerate the members.
            log.Error($"Error reflecting type '{type.Name}'. Properties will not be translated.");
            log.Debug(ex);
        }

        return [];
    }

    static bool SkipMem(ITypeData type, IMemberData mem)
    {
        try
        {
            // If this member is inherited, the translation should happen in the base class.
            if (!Equals(mem.DeclaringType, type))
                return true;
            // Skip the member if it is unbrowsable
            var browsable = mem.GetAttribute<BrowsableAttribute>()?.Browsable;
            if (browsable != null) return !browsable.Value;
            // Otherwise skip the member if it is not writable.
            // This is the primary factor determining whether or not something is visible in most UIs.
            return !mem.Writable;
        }
        catch (Exception ex)
        { 
            log.Error($"Error reflecting member '{type.Name}.{mem.Name}'. This member will not be translated.");
            log.Debug(ex);
            return true;
        }
    }
}