#nullable enable
using System.Diagnostics.CodeAnalysis;
using System.IO;
using T3.Core.Compilation;
using T3.Core.DataTypes;
using T3.Core.IO;
using T3.Core.Operator;
using T3.Core.Operator.Slots;
using T3.Core.Settings;
using T3.Core.Resource;
using T3.Core.Resource.Assets;
using T3.Core.SystemUi;
using T3.Editor.Compilation;
using T3.Editor.Gui;
using T3.Editor.Gui.InputUi.SimpleInputUis;
using T3.Editor.Gui.Interaction.Timing;
using T3.Serialization;

namespace T3.Editor.UiModel.Exporting;

internal static partial class PlayerExporter
{
    public static bool TryExportInstance(Instance composition, SymbolUi.Child childUi, out string reason, out string exportDir)
    {
        T3Ui.Save(false);

        // Collect all ops and types
        var exportedInstance = composition.Children[childUi.SymbolChild.Id];
        var symbol = exportedInstance.Symbol;
        Log.Info($"Exporting {symbol.Name}...");

        var output = exportedInstance.Outputs.FirstOrDefault();
        if (output == null || output.ValueType != typeof(Texture2D))
        {
            reason = "Can only export ops with 'Texture2D' output";
            exportDir = string.Empty;
            return false;
        }

        // Traverse starting at output and collect everything
        var exportData = new ExportData();
        exportData.TryAddSymbol(symbol);

        var package = composition.Symbol.SymbolPackage;
        exportDir = Path.Combine(package.Folder, FileLocations.ExportSubFolder, childUi.SymbolChild.ReadableName);

        if (!TryRemoveExistingExportDir(out reason, exportDir))
            return false;

        Directory.CreateDirectory(exportDir);

        var operatorDir = Path.Combine(exportDir, FileLocations.OperatorsSubFolder);
        Directory.CreateDirectory(operatorDir);

        // Copy assemblies into export dir. Get symbol packages directly used by the exported symbols
        if (!TryExportSymbolPackages(out reason, exportData, operatorDir))
            return false;

        // Get soundtrack or show warning message
        if (TryFindSoundtrack(exportedInstance, symbol, out var address))
        {
            if (AssetRegistry.TryGetAsset(address, out var soundtrackAsset))
            {
                exportData.TryAddSharedAsset(soundtrackAsset);
            }
        }
        else
        {
            const string yes = "Yes";
            var choice = BlockingWindow.Instance.ShowMessageBox("No defined soundtrack found. Continue with export?", "No soundtrack", yes,
                                                                "No, cancel export");

            if (choice != yes)
            {
                reason = $"Failed to find soundTrack for [{symbol.Name}] - export cancelled, see log for details";
                return false;
            }
        }

        // Include implicitly shared assets
        foreach (var shared in (string[]) [
                         "Lib:shaders/dx11/resolve-multisampled-depth-buffer-cs.hlsl",
                         "Lib:pbr/studio_small_08-prefiltered.dds",
                         "Lib:pbr/BRDF-LookUp.dds",
                     ])
        {
            if (AssetRegistry.TryGetAsset(shared, out var soundtrackAsset))
            {
                exportData.TryAddSharedAsset(soundtrackAsset);
            }
            else
            {
                Log.Warning("Can't resolved shared asset " + shared);
            }
        }

        // Collect used assets
        RecursivelyCollectExportData(output, exportData);
        exportData.PrintInfo();

        if (!AssetExportItem.TryCopyItems(exportData.ExportItems, exportDir))
        {
            reason = "Failed to copy resource files - see log for details";
            return false;
        }

        if (!TryExportAssetsOnlyPackages(exportData, operatorDir, out reason))
            return false;

        // Copy shared assets
        var editorResourcesTargetDir = Path.Combine(exportDir, FileLocations.EditorResourcesSubfolder);
        Directory.CreateDirectory(editorResourcesTargetDir);
        if (!TryCopyDirectory(SharedResources.EditorResourcesDirectory, editorResourcesTargetDir, out reason))
            return false;

        // Exclude optional dependency files that are not required by any exported symbol.
        var excludedDependencyFiles = GetUnusedMappedDependencyFiles(exportData);
        var playerDirectory = Path.Combine(FileLocations.StartFolder, "Player");
        if (!TryCopyDirectory(playerDirectory,
                              exportDir,
                              out reason,
                              excludeFiles: excludedDependencyFiles))
            return false;

        if (!TryExportSettings(exportDir, symbol, out reason))
            return false;

        reason = "Exported successfully to " + exportDir;
        return true;
    }

    /// <summary>
    /// Compile EditableProjects and copy read only projects.  
    /// </summary>
    private static bool TryExportSymbolPackages(out string reason, ExportData exportData, string operatorDir)
    {
        string[] excludeSubdirectories =
            [
                ".git",
                FileLocations.SymbolUiSubFolder,
                FileLocations.SourceCodeSubFolder,
                FileLocations.ExportSubFolder,
                FileLocations.AssetsSubfolder, // Assets are filtered by referencing address and copied separately 
            ];

        foreach (var package in exportData.SymbolPackages)
        {
            Log.Debug($"Exporting package {package.Name}...");
            var packageName = package.Name;
            var targetDirectory = Path.Combine(operatorDir, packageName);
            Directory.CreateDirectory(targetDirectory);

            if (package is EditableSymbolProject project)
            {
                project.SaveModifiedSymbols();
                if (!project.CsProjectFile.TryCompileRelease(false, out var failureLog))
                {
                    reason = $"Failed to compile project \"{packageName}\" - \n{failureLog}";
                    return false;
                }

                // Copy the resulting directory into the target directory
                var sourceDir = project.CsProjectFile.GetBuildTargetDirectory(CsProjectFile.PlayerBuildMode);

                // Copy contents recursively into the target directory
                if (!TryCopyDirectory(sourceDir, targetDirectory, out reason, excludeSubdirectories))
                    return false;
            }
            else
            {
                // Copy full directory into target directory recursively, maintaining folder layout
                var directoryToCopy = package.AssemblyInformation.Directory;

                if (!TryCopyDirectory(directoryToCopy, targetDirectory, out reason, excludeSubdirectories))
                    return false;
            }
        }

        reason = string.Empty;
        return true;
    }

    /// <summary>
    /// If only Assets but no Symbols are used from a package, we still need to copy its OperatorPackage.json file,
    /// so the player can register these assets on startup. 
    /// </summary>
    private static bool TryExportAssetsOnlyPackages(ExportData exportData, string operatorDir, out string reason)
    {
        reason = string.Empty;
        foreach (var assetPackage in exportData.AssetPackages)
        {
            var alreadyIncluded = exportData.SymbolPackages.Any(sp => sp.Id == assetPackage.Id);
            if (alreadyIncluded)
                continue;

            var sourcePath = Path.Combine(assetPackage.Folder, ReleaseInfo.FileName);
            var targetPath = Path.Combine(operatorDir, assetPackage.Name, ReleaseInfo.FileName);

            if (!TryCopyFile(sourcePath, targetPath))
            {
                reason = $"Failed to copy {sourcePath} for asset package {assetPackage}";
                return false;
            }
        }

        return true;
    }

    /// <summary>
    /// Recursively copies a directory to a target directory, excluding specified subfolders, files, and file extensions.
    /// </summary>
    private static bool TryCopyDirectory(string directoryToCopy, string targetDirectory, out string reason, string[]? excludeSubFolders = null,
                                         string[]? excludeFiles = null, string[]? excludeFileExtensions = null)
    {
        try
        {
            var rootFiles = Directory.EnumerateFiles(directoryToCopy, "*", SearchOption.TopDirectoryOnly);
            var subfolderFiles = Directory.EnumerateDirectories(directoryToCopy, "*", SearchOption.TopDirectoryOnly)
                                          .Where(subDir =>
                                                 {
                                                     if (excludeSubFolders == null)
                                                         return true;

                                                     var dirName = Path.GetRelativePath(directoryToCopy, subDir);
                                                     foreach (var excludeSubFolder in excludeSubFolders)
                                                     {
                                                         if (string.Equals(dirName, excludeSubFolder, StringComparison.OrdinalIgnoreCase))
                                                         {
                                                             return false;
                                                         }
                                                     }

                                                     return true;
                                                 })
                                          .SelectMany(subDir => Directory.EnumerateFiles(subDir, "*", SearchOption.AllDirectories));

            var files = rootFiles.Concat(subfolderFiles);
            var shouldExcludeFiles = excludeFiles != null;
            var shouldExcludeFileExtensions = excludeFileExtensions != null;
            foreach (var file in files)
            {
                if (shouldExcludeFiles && excludeFiles!.Contains(Path.GetFileName(file)))
                    continue;

                bool shouldSkipBasedOnExtension = false;
                if (shouldExcludeFileExtensions)
                {
                    foreach (var extension in excludeFileExtensions!)
                    {
                        if (file.EndsWith(extension, StringComparison.OrdinalIgnoreCase))
                        {
                            shouldSkipBasedOnExtension = true;
                            break;
                        }
                    }
                }

                if (shouldSkipBasedOnExtension)
                    continue;

                var relativePath = Path.GetRelativePath(directoryToCopy, file);
                var targetPath = Path.Combine(targetDirectory, relativePath);
                var targetDir = Path.GetDirectoryName(targetPath);
                if (targetDir == null)
                {
                    reason = $"Failed to get directory for \"{targetPath}\" - is it missing a file extension?";
                    return false;
                }

                Directory.CreateDirectory(targetDir);
                File.Copy(file, targetPath, true);
            }
        }
        catch (Exception e)
        {
            reason = $"Failed to copy directory {directoryToCopy} to {targetDirectory}. Exception:\n{e}";
            return false;
        }

        reason = string.Empty;
        return true;
    }

    private static bool TryCopyFile(string sourcePath, string targetPath)
    {
        var directory = Path.GetDirectoryName(targetPath);
        try
        {
            Directory.CreateDirectory(directory!);
            File.Copy(sourcePath, targetPath, true);
            return true;
        }
        catch (Exception e)
        {
            Log.Error($"Failed to copy resource file for export: {sourcePath}  {e.Message}");
        }

        return false;
    }

    private static void RecursivelyCollectExportData(ISlot slot, ExportData exportData)
    {
        var gotConnection = slot.TryGetFirstConnection(out var firstConnection);
        if (slot is IInputSlot)
        {
            if (gotConnection)
            {
                RecursivelyCollectExportData(firstConnection, exportData);
            }

            CheckInputForResourcePath(slot, exportData);
            return;
        }

        if (gotConnection)
        {
            // slot is an output of an composition op
            RecursivelyCollectExportData(firstConnection, exportData);
            exportData.TryAddInstance(slot.Parent);
            return;
        }

        var parent = slot.Parent;

        if (!exportData.TryAddInstance(parent))
            return; // already visited

        foreach (var input in parent.Inputs)
        {
            CheckInputForResourcePath(input, exportData);

            if (!input.HasInputConnections)
                continue;

            if (input.TryGetAsMultiInput(out var multiInput))
            {
                foreach (var entry in multiInput.GetCollectedInputs())
                {
                    RecursivelyCollectExportData(entry, exportData);
                }
            }
            else if (input.TryGetFirstConnection(out var inputsFirstConnection))
            {
                RecursivelyCollectExportData(inputsFirstConnection, exportData);
            }
        }
    }

    private static bool TryFindSoundtrack(Instance instance, Symbol symbol,
                                          [NotNullWhen(true)] out string? address)
    {
        var playbackSettings = symbol.CompositionSettings;
        if (playbackSettings == null)
        {
            Log.Warning($"Project {symbol} has no playback settings");
            address = null;
            return false;
        }

        if (playbackSettings.TryGetMainSoundtrack(instance, out var soundtrack) is not true)
        {
            if (PlaybackUtils.TryFindingSoundtrack(out soundtrack, out _))
            {
                Log.Warning($"You should define soundtracks withing the exported operators. Falling back to {soundtrack.Clip.AssetPath} set in parent...");
            }
            else
            {
                address = null;
                return false;
            }

            Log.Debug("No soundtrack defined within operator.");
        }

        address = soundtrack.Clip.AssetPath;
        return FileResource.TryGetFileResource(soundtrack.Clip.AssetPath, instance, out _);
    }

    private static void CheckInputForResourcePath(ISlot inputSlot, ExportData exportData)
    {
        var parent = inputSlot.Parent;
        var inputUi = parent.GetSymbolUi().InputUis[inputSlot.Id];
        if (inputUi is not StringInputUi stringInputUi)
            return;

        if (stringInputUi.Usage != StringInputUi.UsageType.FilePath && stringInputUi.Usage != StringInputUi.UsageType.DirectoryPath)
            return;

        var compositionSymbol = parent.Parent?.Symbol;
        if (compositionSymbol == null)
            return;

        var parentSymbolChild = compositionSymbol.Children[parent.SymbolChildId];
        var value = parentSymbolChild.Inputs[inputSlot.Id].Value;
        if (value is not InputValue<string> stringValue)
            return;

        var address = stringValue.Value;

        switch (stringInputUi.Usage)
        {
            case StringInputUi.UsageType.FilePath:
            {
                if (!AssetRegistry.TryGetAsset(address, out var asset))
                {
                    Log.Warning($" Asset not found '{address}'");
                    break;
                }

                exportData.TryAddSharedAsset(asset);
                break;
            }
            case StringInputUi.UsageType.DirectoryPath:
            {
                //var relativeDirectory = stringValue.Value;
                //var isFolder = relativeDirectory.EndsWith('/');

                if (!AssetRegistry.TryResolveAddress(address, parent, out var absoluteDirectory, out var package, isFolder: true))
                {
                    Log.Warning($" Directory '{address}' was not found in any resource folder");
                    break;
                }

                // if (package == null)
                // {
                //     Log.Warning($"Directory '{address}' can't be exported without a package");
                //     break;
                // }

                Log.Debug($"Export all files in folder {absoluteDirectory}...");
                foreach (var absolutePath in Directory.EnumerateFiles(absoluteDirectory, "*", SearchOption.AllDirectories))
                {
                    var relativePathInResourceFolder = Path.GetRelativePath(package.AssetsFolder, absolutePath);

                    exportData.TryAddExportAsset(new AssetExportItem(package.RootNamespace,
                                                                     relativePathInResourceFolder,
                                                                     absolutePath));
                }

                break;
            }
            case StringInputUi.UsageType.Default:
            case StringInputUi.UsageType.Multiline:
            case StringInputUi.UsageType.CustomDropdown:
            default:
                break;
        }
    }

    private static bool TryExportSettings(string exportDir, Symbol symbol, out string reason)
    {
        reason = string.Empty;

        // Update project settings
        var exportSettings = new ExportSettings(OperatorId: symbol.Id,
                                                ApplicationTitle: symbol.Name,
                                                WindowMode: CompositionSettings.Current.Export.DefaultWindowMode,
                                                ConfigData: CoreSettings.Config,
                                                Author: symbol.SymbolPackage.AssemblyInformation?.Name ?? string.Empty, // todo - actual author name
                                                BuildId: Guid.NewGuid(),
                                                EditorVersion: Program.VersionText);

        const string exportSettingsFile = "exportSettings.json";
        if (JsonUtils.TrySaveJson(exportSettings, Path.Combine(exportDir, exportSettingsFile)))
            return true;

        reason = $"Failed to save export settings to {exportSettingsFile}";
        return false;
    }

    private static bool TryRemoveExistingExportDir(out string reason, string exportDir)
    {
        try
        {
            if (Directory.Exists(exportDir))
            {
                Directory.Delete(exportDir, recursive: true);
            }
        }
        catch (Exception e)
        {
            reason = $"Failed to remove export dir: {exportDir} ({e.Message}). Please close all files and File Explorer windows.";
            return false;
        }

        reason = string.Empty;
        return true;
    }

    private static string[] GetUnusedMappedDependencyFiles(ExportData exportData)
    {
        var requiredFiles = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        var allMappedFiles = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

        foreach (var definition in _dependencyDefinitions)
        {
            foreach (var filename in definition.Filenames)
            {
                allMappedFiles.Add(filename);
            }

            var isRequired = false;
            foreach (var symbolId in definition.SymbolIds)
            {
                if (!exportData.ContainsSymbolId(symbolId))
                    continue;

                isRequired = true;
                break;
            }

            if (!isRequired)
                continue;

            foreach (var filename in definition.Filenames)
            {
                requiredFiles.Add(filename);
            }
        }

        allMappedFiles.ExceptWith(requiredFiles);
        return allMappedFiles.ToArray();
    }

    private sealed record OpDependencyDefinition(List<Guid> SymbolIds, List<string> Filenames);

    private static readonly List<OpDependencyDefinition> _dependencyDefinitions =
    [
        new([new Guid("31ab98ec-5e79-4667-9a85-2fb168f41fa1")], [
            "AbletonLink.deps.json",
            "AbletonLinkDLL.dll",
            "AbletonLink.dll",
        ]),
        // Things related to webcams and MediaPipe
        new([
            new Guid("cd5a182e-254b-4e65-820b-ff754122614c"), // VideoDeviceInput
            new Guid("A1B2C3D4-E5F6-4798-89AB-CDEF12345679"), // MediaPipeFaceDetection
            new Guid("9b2c3d4e-5f6a-4798-89ab-cdef12345678"), // FaceLandmark
            new Guid("4567890a-bcde-f123-4567-890abcdef123"), // HandLandmark
            new Guid("23456789-0abc-def1-2345-67890abcdef1"), // Image Segmentation
            new Guid("12345678-90ab-cdef-1234-567890abcdef"), // Object Detection 
            new Guid("34567890-abcd-ef12-3456-7890abcdef12"), // PoseLandmarkDetection  
            new Guid("8b23c93b-3b45-4c9b-9c23-4d5e6f7a8b9c"), // OnvifCamera
            new Guid("7b4d3c2a-5b16-4b2a-8f3a-7e8c9d0b1a2b"), // CameraCalibrartor  
            // VideoStreamInput decodes via FFmpeg (the LGPL build shipped with the Video operator package, to
            // which it has now moved), so it no longer needs the OpenCV DLLs.
        ], [
            "mediapipe_c.dll",
            "Emgu.CV.dll",
            "Processing.NDI.Lib.x64.dll",
            "OpenGL.Net.dll",
            "OpenCvSharp.Extensions.dll",
             "OpenCvSharpExtern.dll",
            "opencv_videoio_ffmpeg4110_64.dll",
            "DirectShowLib.dll",
            "cvextern.dll",
        ]),

        // NDI
        new([
            new Guid("7567c3b0-9d91-40d2-899d-3a95b481d023"), // NdiInput
            new Guid("9412d0f4-dab8-4145-9719-10395e154fa7"), // NdiOutput
        ], [
            "NDILibDotNet6.dll",
        ]),
        
        // Unsplash
        new([
            new Guid("89162b9f-75f5-4d32-9d28-8259cf47cf58"), 
        ], [
            "Unsplasharp.dll",
        ]),

        
        new([
            new Guid("fc03dcd0-6f2f-4507-be06-1ed105607489"), //ArtnetInput
            new Guid("98efc7c8-cafd-45ee-8746-14f37e9f59f8"), //ArtnetOutput
            new Guid("faa3e182-96e6-45e7-b037-fb2acd88825b"), //ArtnetPixelOutput
        ], [
            "ArtNet.dll",
        ]),
    ];
}