using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading;
using Barotrauma.Extensions;
using Barotrauma.LuaCs.Data;
using Barotrauma.LuaCs.Services.Processing;

namespace Barotrauma.LuaCs.Services;

public partial class PackageService : IPackageService
{
    private readonly ReaderWriterLockSlim _operationsUsageLock = new();
    // only stops race conditions for pointer access
    
    
    // mod config / package scanners/parsers
    private readonly Lazy<IXmlModConfigConverterService> _modConfigConverterService;
    private readonly Lazy<ILegacyConfigService> _legacyConfigService;
    private readonly Lazy<ILuaScriptService> _luaScriptService;
    private readonly Lazy<ILocalizationService> _localizationService;
    private readonly Lazy<IPluginService> _pluginService;
    private readonly Lazy<IConfigService> _configService;
    private readonly IPackageManagementService _packageManagementService;
    private readonly IStorageService _storageService;
    private readonly ILoggerService _loggerService;
    
    // .ctor in server source and client source
    
    // state monitors
    private int _configsLoaded, _localizationsLoaded, _luaScriptsLoaded, _pluginsLoaded, _isDisposed;
    private int _loadingOperationsRunning;

    public bool ConfigsLoaded
    {
        get => GetThreadSafeBool(ref _configsLoaded);
        private set => SetThreadSafeBool(ref _configsLoaded, value);
    }
    public bool LocalizationsLoaded
    {
        get => GetThreadSafeBool(ref _localizationsLoaded);
        private set => SetThreadSafeBool(ref _localizationsLoaded, value);
    }
    public bool LuaScriptsLoaded
    {
        get => GetThreadSafeBool(ref _luaScriptsLoaded);
        private set => SetThreadSafeBool(ref _luaScriptsLoaded, value);
    }
    public bool PluginsLoaded
    {
        get => GetThreadSafeBool(ref _pluginsLoaded);
        private set => SetThreadSafeBool(ref _pluginsLoaded, value);
    }
    public bool IsDisposed
    {
        get => GetThreadSafeBool(ref _isDisposed);
        private set => SetThreadSafeBool(ref _isDisposed, value);
    }

    private bool LoadingOperationsRunning
    {
        get => Interlocked.CompareExchange(ref _loadingOperationsRunning, 0, 0) > 0;
        set // we use the set as our inc/decr 
        {
            if (value)
            {
                Interlocked.Add(ref _loadingOperationsRunning, 1);
            }
            else
            {
                Interlocked.Add(ref _loadingOperationsRunning, -1);
            }
        }
    }
    
    #region Member: ContentPackage

    private readonly ReaderWriterLockSlim _packageAccessLock = new();
    private ContentPackage _package;
    public ContentPackage Package
    {
        get
        {
            _packageAccessLock.EnterReadLock();
            try
            {
                return _package;
            }
            finally
            {
                _packageAccessLock.ExitReadLock();
            }
        }
        private set
        {
            _packageAccessLock.EnterWriteLock();
            try
            {
                _package = value;
            }
            finally
            {
                _packageAccessLock.ExitWriteLock();
            }
        }
    }

    #endregion

    #region DataContracts

    #region Member: ModConfigInfo

    private readonly ReaderWriterLockSlim _modConfigUsageLock = new();
    private IModConfigInfo _modConfigInfo;
    public IModConfigInfo ModConfigInfo
    {
        get
        {
            _modConfigUsageLock.EnterReadLock();
            try
            {
                return _modConfigInfo;
            }
            finally
            {
                _modConfigUsageLock.ExitReadLock();
            }
        }
        private set
        {
            _modConfigUsageLock.EnterWriteLock();
            try
            {
                _modConfigInfo = value;
            }
            finally
            {
                _modConfigUsageLock.ExitWriteLock();
            }
        }
    }

    #endregion
    
    public ImmutableArray<CultureInfo> SupportedCultures => ModConfigInfo?.SupportedCultures ?? ImmutableArray<CultureInfo>.Empty;
    public ImmutableArray<IAssemblyResourceInfo> Assemblies => ModConfigInfo?.Assemblies ?? ImmutableArray<IAssemblyResourceInfo>.Empty;
    public ImmutableArray<ILocalizationResourceInfo> Localizations => ModConfigInfo?.Localizations ?? ImmutableArray<ILocalizationResourceInfo>.Empty;
    public ImmutableArray<ILuaResourceInfo> LuaScripts => ModConfigInfo?.LuaScripts ?? ImmutableArray<ILuaResourceInfo>.Empty;
    public ImmutableArray<IConfigResourceInfo> Configs => ModConfigInfo?.Configs ?? ImmutableArray<IConfigResourceInfo>.Empty;
    public ImmutableArray<IConfigProfileResourceInfo> ConfigProfiles => ModConfigInfo?.ConfigProfiles ?? ImmutableArray<IConfigProfileResourceInfo>.Empty;

    #endregion

    #region PublicAPI

    public bool TryLoadResourcesInfo(ContentPackage package)
    {
        _operationsUsageLock.EnterWriteLock();
        LoadingOperationsRunning = true;
        try
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException($"This package service instance is disposed!");
            }

            // try loading the ModConfig.xml. If it fails, use the Legacy loader to try and construct one from the package structure.
            if (_storageService.TryLoadPackageXml(package, "ModConfig.xml", out var configXml)
                && configXml.Root is not null)
            {
                if (_modConfigConverterService.Value.TryParseResource(configXml.Root, out IModConfigInfo configInfo))
                {
                    ModConfigInfo = configInfo;
                }
                else
                {
                    _loggerService.LogError(
                        $"Failed to parse ModConfig.xml for package {package.Name}, package mod content not loaded.");
                    return false;
                }
            }
            else if (_legacyConfigService.Value.TryBuildModConfigFromLegacy(package, out var legacyConfig))
            {
                ModConfigInfo = legacyConfig;
            }
            else
            {
                // vanilla mod or broken
                return false;
            }

            return true;
        }
        finally
        {
            LoadingOperationsRunning = false;
            _operationsUsageLock.ExitWriteLock();
        }
    }

    public void LoadPlugins([NotNull]IAssembliesResourcesInfo assembliesInfo, bool ignoreDependencySorting = false)
    {
        _operationsUsageLock.EnterReadLock();
        LoadingOperationsRunning = true;
        try
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException($"This package service instance is disposed!");
            }
            
            SanitationChecksCore(assembliesInfo, "assemblies", nameof(LoadPlugins));
            SanitationChecksEnumerable(assembliesInfo.Assemblies, "assemblies", nameof(LoadPlugins));

#if DEBUG
            assembliesInfo.Assemblies.ForEach(ari =>
            {
                if (!this.Assemblies.Contains(ari))
                {
                    throw new ArgumentException(
                        $"Package Service: tried to load the assembly resource {ari.InternalName} for package {this.Package.Name} but it is not in the list for this package.");
                }
            });      
#endif
            
            // Order these assemblies by internal dependencies
            ImmutableArray<IAssemblyResourceInfo> resources;
            if (ignoreDependencySorting)
            {
                resources = assembliesInfo.Assemblies;
            }
            else // sort by load order
            {
                resources = assembliesInfo.Assemblies
                    .OrderByDescending(a => a.LoadPriority)
                    .ToImmutableArray();
            }
            
            // Try loading them, throw on failure.
            if (!_pluginService.Value.TryLoadAndInstanceTypes<IAssemblyPlugin>(resources, true, out var instancedTypes))
            {
                throw new TypeLoadException($"PackageService: unable to load assemblies for package {this.Package.Name}! Aborting loading!");
            }

            PluginsLoaded = true;
        }
        finally
        {
            LoadingOperationsRunning = false;
            _operationsUsageLock.ExitReadLock();
        }
    }

    public void LoadLocalizations([NotNull]ILocalizationsResourcesInfo localizationsInfo)
    {
        _operationsUsageLock.EnterReadLock();
        LoadingOperationsRunning = true;
        try
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException($"This package service instance is disposed!");
            }
            
            SanitationChecksCore(localizationsInfo, "localizations", nameof(LoadLocalizations));
            SanitationChecksEnumerable(localizationsInfo.Localizations, "localizations", nameof(LoadLocalizations));

#if DEBUG
            localizationsInfo.Localizations.ForEach(ri =>
            {
                if (!this.Localizations.Contains(ri))
                {
                    throw new ArgumentException(
                        $"Package Service: tried to load the localization resource for package {this.Package.Name} but it is not in the list for this package.");
                }
            });      
#endif
            
            if (!_localizationService.Value.TryLoadLocalizations(localizationsInfo.Localizations))
            {
                throw new FileLoadException($"Package Service: unable to load localizations for package {this.Package.Name}! Aborting!");
            }

            LocalizationsLoaded = true;
        }
        finally
        {
            LoadingOperationsRunning = false;
            _operationsUsageLock.ExitReadLock();
        }
    }

    public void AddLuaScripts([NotNull]ILuaScriptsResourcesInfo luaScriptsInfo)
    {
        _operationsUsageLock.EnterReadLock();
        LoadingOperationsRunning = true;
        try
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException($"This package service instance is disposed!");
            }
            
            SanitationChecksCore(luaScriptsInfo, "luaScripts", nameof(AddLuaScripts));
            SanitationChecksEnumerable(luaScriptsInfo.LuaScripts, "luaScripts", nameof(AddLuaScripts));

#if DEBUG
            luaScriptsInfo.LuaScripts.ForEach(ri =>
            {
                if (!this.LuaScripts.Contains(ri))
                {
                    throw new ArgumentException(
                        $"Package Service: tried to load the lua script resource for package {this.Package.Name} but it is not in the list for this package.");
                }
            });      
#endif
            
            if (!_luaScriptService.Value.TryAddScriptFiles(luaScriptsInfo.LuaScripts))
            {
                throw new ArgumentException(
                    $"Package Service: unable to add lua files for package {this.Package.Name}! Aborting!");
            }

            LuaScriptsLoaded = true;
        }
        finally
        {
            LoadingOperationsRunning = false;
            _operationsUsageLock.ExitReadLock();
        }
    }

    public void LoadConfig(
        [NotNull]IConfigsResourcesInfo configsResourcesInfo, 
        [NotNull]IConfigProfilesResourcesInfo configProfilesResourcesInfo)
    {
        _operationsUsageLock.EnterReadLock();
        LoadingOperationsRunning = true;
        try
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException($"This package service instance is disposed!");
            }
            
            SanitationChecksCore(configsResourcesInfo, "config", nameof(LoadConfig));
            SanitationChecksCore(configProfilesResourcesInfo, "config profiles", nameof(LoadConfig));
            SanitationChecksEnumerable(configsResourcesInfo.Configs, "config", nameof(LoadConfig));
            SanitationChecksEnumerable(configProfilesResourcesInfo.ConfigProfiles, "config profiles", nameof(LoadConfig));

#if DEBUG
            configsResourcesInfo.Configs.ForEach(ri =>
            {
                if (!this.Configs.Contains(ri))
                {
                    throw new ArgumentException(
                        $"Package Service: tried to load the configs resource for package {this.Package.Name} but it is not in the list for this package.");
                }
            }); 
            
            configProfilesResourcesInfo.ConfigProfiles.ForEach(ri =>
            {
                if (!this.ConfigProfiles.Contains(ri))
                {
                    throw new ArgumentException(
                        $"Package Service: tried to load the localization resource for package {this.Package.Name} but it is not in the list for this package.");
                }
            }); 
#endif
            
            if (!_configService.Value.TryAddConfigs(configsResourcesInfo.Configs))
            {
                throw new ArgumentException(
                    $"Package Service: unable to add configs for package {this.Package.Name}! Aborting!");
            }
            
            if (!_configService.Value.TryAddConfigsProfiles(configProfilesResourcesInfo.ConfigProfiles))
            {
                throw new ArgumentException(
                    $"Package Service: unable to add configs profiles for package {this.Package.Name}! Aborting!");
            }
            ConfigsLoaded = true;
        }
        finally
        {
            LoadingOperationsRunning = false;
            _operationsUsageLock.ExitReadLock();
        }
    }

    public void Dispose()
    {
        /*
         * Notes: we need to unload this package from services in the order that the services are dependent on each other.
         * Unloading Order: Lua Scripts > Assemblies > Config Profiles > Configs > Styles > Localizations
         */
        _operationsUsageLock.EnterWriteLock();
        try
        {
            if (this.Package is null)
            {
                _loggerService.LogError(
                    $"Package Service: cannot Dispose of service as ContentPackage and info is not set!");
                return;
            }

            if (this.ModConfigInfo is null)
            {
                _loggerService.LogError($"Package Service: cannot Dispose of service as ModConfigInfo is not loaded!");
                return;
            }

            /*
             * To be graceful, we want to ensure that any async calls and other threads are allowed to be processed before we begin
             * disposal to reduce friction with other thread operations, so we release the lock and periodically check it
             * to see of other threads have finished operations before cleaning everything up.
             */

            IsDisposed = true; // set stop flag, callers should handle exception cases
            Interlocked.MemoryBarrier(); //ensure cache states 

            DateTime timeoutLimit = DateTime.Now.AddSeconds(10);
            while (LoadingOperationsRunning)
            {
                _operationsUsageLock.ExitWriteLock();
                Thread.Sleep(1);
                _operationsUsageLock.EnterWriteLock();
                if (timeoutLimit < DateTime.Now)
                {
                    _loggerService.LogError($"Package Service: Dispose() time out reached while waiting for other operations. Continuing.");
                    break;
                }
            }
            
            GC.SuppressFinalize(this);

            _luaScriptService.Value.RemoveScriptFiles(this.LuaScripts);
            _pluginService.Value.DisposePlugins();
            _configService.Value.RemoveConfigsProfiles(this.ConfigProfiles);
            _configService.Value.RemoveConfigs(this.Configs);
#if CLIENT
            _stylesService.Value.UnloadAllStyles();
#endif
            _localizationService.Value.Remove(this.Localizations);

            ModConfigInfo = null;
            Package = null;
        }
        catch
        {
            _loggerService.LogError($"Package Service: exception while running Dispose().");
            throw;
        }
        finally
        {
            _operationsUsageLock.ExitWriteLock();
        }
    }

    public void Reset()
    {
        _operationsUsageLock.EnterWriteLock();
        try
        {
            if (this.Package is null)
            {
                _loggerService.LogError(
                    $"Package Service: cannot Dispose of service as ContentPackage and info is not set!");
                return;
            }

            if (this.ModConfigInfo is null)
            {
                _loggerService.LogError($"Package Service: cannot Dispose of service as ModConfigInfo is not loaded!");
                return;
            }
            
            Interlocked.MemoryBarrier(); //ensure cache states 

            DateTime timeoutLimit = DateTime.Now.AddSeconds(10);
            while (LoadingOperationsRunning)
            {
                _operationsUsageLock.ExitWriteLock();
                Thread.Sleep(1);
                _operationsUsageLock.EnterWriteLock();
                if (timeoutLimit < DateTime.Now)
                {
                    _loggerService.LogError($"Package Service: Dispose() time out reached while waiting for other operations. Continuing.");
                    break;
                }
            }

            if (LuaScriptsLoaded)
            {
                _luaScriptService.Value.RemoveScriptFiles(this.LuaScripts);
                LuaScriptsLoaded = false;
            }

            if (PluginsLoaded)
            {
                _pluginService.Value.DisposePlugins();
                PluginsLoaded = false;
            }

            if (ConfigsLoaded)
            {
                _configService.Value.RemoveConfigsProfiles(this.ConfigProfiles);
                _configService.Value.RemoveConfigs(this.Configs);
                ConfigsLoaded = false;
            }

            if (LocalizationsLoaded)
            {
                _localizationService.Value.Remove(this.Localizations);
                LocalizationsLoaded = false;
            }
        }
        finally
        {
            _operationsUsageLock.ExitWriteLock();
        }
    }

    #endregion

    #region INTERNAL

    private void SanitationChecksCore(object o, string resTypeInfoName, string callerName)
    {
        if (o is null)
        {
            _loggerService.LogError($"Package Service: {resTypeInfoName} resources list is null!");
            throw new NullReferenceException($"Package Service: {resTypeInfoName} resources list is null!");
        }

        if (this.Package is null)
        {
            _loggerService.LogError($"Package Service: package not set at {callerName}()!");
            throw new NullReferenceException($"Package Service: package not set at {callerName}()!");
        }
    }
    
    private void SanitationChecksEnumerable<T>(ImmutableArray<T> resourceInfos, string resTypeInfoName, string callerName) where T : IResourceInfo, IResourceCultureInfo, IPackageInfo, IPackageDependenciesInfo
    {
        // Check if list is empty. Nothing more to do.
        if (resourceInfos.IsDefaultOrEmpty)
            return;

        // Check if all resources in the list are registered to this package, throw if not.
        foreach (var resourceInfo in resourceInfos)
        {
            // ownership checks
            if (resourceInfo.OwnerPackage is null)
            {
                throw new ArgumentException($"Package Service: {resTypeInfoName} info for resource does not have a package name set! Run by {this.Package.Name}.");
            }

            if (resourceInfo.OwnerPackage != this.Package)
            {
                throw new ArgumentException(
                    $"Package Service: {resTypeInfoName} info does not belong to this package! Owned by {resourceInfo.OwnerPackage.Name} but is run by {this.Package.Name}.");
            }
            
            // Check if external dependencies are loaded and if current environment is supported, throw if not
            if (resourceInfo.Dependencies.IsDefaultOrEmpty)
                continue;
            
            bool resourceMissing = false;
            
            resourceInfo.Dependencies.ForEach(pdi =>
            {
                // for clarification: assemblies passed to the function should always be loaded.
                // optional assemblies should be filtered out before the list is sent.
                // left this as a reminder :)
                /*if (pdi.Optional)
                    return;*/
                if (!_packageManagementService.CheckDependencyLoaded(pdi))
                {
                    resourceMissing = true;
                    _loggerService.LogError(
                        $"Package Service: the following dependency for package {resourceInfo.OwnerPackage.Name} is not loaded: {pdi.DependencyPackage?.Name ?? (pdi.PackageName.IsNullOrWhiteSpace() ? pdi.SteamWorkshopId.ToString() : pdi.PackageName)}");
                }
            });

            if (!resourceMissing)
            {
                throw new FileLoadException($"Package Service: dependencies for package {resourceInfo.OwnerPackage.Name} are not loaded.");
            }
            
            // check runtime platform
            if (!_packageManagementService.CheckEnvironmentSupported(resourceInfo))
            {
                throw new PlatformNotSupportedException($"Package service: the {resTypeInfoName} from {resourceInfo.OwnerPackage.Name} is not supported on this platform.");
            }
            
            // check local culture
            if (!_localizationService.Value.IsCurrentCultureSupported(resourceInfo))
            {
                throw new PlatformNotSupportedException($"Package service: the {resTypeInfoName} from {resourceInfo.OwnerPackage.Name} is not supported in this culture.");
            }
        }
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static bool GetThreadSafeBool(ref int var) => Interlocked.CompareExchange(ref var, 1, 1) == 1;
    
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static void SetThreadSafeBool(ref int var, bool value)
    {
        if (value)
        {
            Interlocked.CompareExchange(ref var, 1, 0);
        }
        else
        {
            Interlocked.CompareExchange(ref var, 0, 1);
        }
    }
    
    #endregion
}