using System;
using System.Collections.Generic;

using UnityEngine;

using Ubisoft.Hotel.Logger.Editor;
using Ubisoft.Hotel.Package;
using Ubisoft.Hotel.Package.Editor;

namespace Ubisoft.Hotel.PackageManager.Editor
{
    public abstract class PackageSuiteBuilder
    {
        private readonly Dictionary<string, string> m_packages;
        private readonly List<string> m_packageSuiteNames;
        private readonly string m_buildNamePrefix;
        private readonly bool m_addPipelineInfoAsSufix;        

        /// <summary>
        /// Create a new PackageSuiteBuilder
        /// </summary>
        /// <param name="packages">Dictionary containing <packageName, packageVersion> pairs with the packages that PackageManager needs to handle.</param>
        /// <param name="packageSuiteNames">List of package suite names.</param>
        /// <param name="buildNamePrefix">Prefix for the file name of the artifact generated as a result of building.</param>
        /// <param name="addPipelineInfoAsSufix">Add pipeline information (branchName_buildNumber) to the file name of the artifact generated as a result of building.</param>
        public PackageSuiteBuilder(Dictionary<string, string> packages, List<string> packageSuiteNames, string buildNamePrefix = "", bool addPipelineInfoAsSufix = false)
        {
            m_packages = packages;
            m_packageSuiteNames = packageSuiteNames;
            m_buildNamePrefix = buildNamePrefix;
            m_addPipelineInfoAsSufix = addPipelineInfoAsSufix;

            // Former versions of HPM required to create PackageManager.ASSETS_HOTEL_EDITOR_PLUGGABLE_PACKAGES
            // This is not required anymore but we need to make sure that it will be deleted from consumer's space
            RemovePluggablePackages();
        }

        private void RemovePluggablePackages()
        {
            if (HtAssetDatabase.ExistsFile(PackageManager.ASSETS_HOTEL_EDITOR_PLUGGABLE_PACKAGES))
            {
                HtAssetDatabase.DeleteFile(PackageManager.ASSETS_HOTEL_EDITOR_PLUGGABLE_PACKAGES, false);
            }
        }

        public virtual bool IsEnabled()
        {
            return true;
        }

        public Dictionary<string, string> GetPackagesHandledByConsumer()
        {
            return m_packages;
        }

        public List<string> GetPackageSuiteNames()
        {
            return m_packageSuiteNames;
        }

        /// <summary>
        /// Process parameters passed in to BuildPlayer. This method can be used by consumers to process game specific parameters.
        /// </summary>
        /// <param name="parameters"</param>
        public virtual void ProcessBuildParameters(Dictionary<string, string> parameters)
        {
        }

        /// <summary>
        /// Generate a <c>PackageSuite</c> object given a package suite name and a collection of pairs (<property_key>,<property_value>) that
        /// must override the setup for the <c>PackageSuite</c> called <c>packageSuiteName</c>
        /// </summary>
        ///
        /// <param name="platform">Platform to generate suites for.</param>
        ///
        /// <param name="packageSuiteName">Name of the <c>PackageSuite</c> object to create.</param>
        ///
        /// <param name="overridingProperties">A dictionary containing a collection of pairs (<property_key>,<property_value>), which are meant to override
        /// the values defined for the setup of <c>packageSuiteName</c>. If <c>null</c> is passed in then the <c>PackageSuite</c> object
        /// corresponding to <c>packageSuiteName</c> will be returned as it is, with no properties overridden.
        /// This parameter is used to keep the amount of <c>PackageSuite</c> definitions manageable by letting you reuse the same <c>PackageSuite</c>
        /// definition when you only want to change some properties such as the scheme (debug, release, prerelease) or the network environment (dev, stage, prod).
        /// This parameter is usually filled in from CLI, typically by the CI/CD pipeline.</param>
        ///
        /// <returns>A <c>PackageSuite</c> object containing a set of properties that configure the build for a particular situation.</returns>
        public virtual PackageSuite GeneratePackageSuite(EPlatform platform, string packageSuiteName, Dictionary<string, string> overridingProperties = null)
        {
            PackageSuite returnValue = null;

            if (m_packageSuiteNames.Contains(packageSuiteName))
            {
                PackageSuiteSetup packageSuiteSetup = GetPackageSuiteSetup(packageSuiteName);
                if (packageSuiteSetup != null)
                {
                    // Create a PackageSuite object
                    returnValue = CreatePackageSuite(packageSuiteName);

                    packageSuiteSetup.Override(overridingProperties);

                    Type type;
                    int valueIndex;
                    foreach (string key in packageSuiteSetup.Keys)
                    {
                        type = PackageSuiteSetup.GetTypeByKey(key);
                        valueIndex = packageSuiteSetup.GetSelectedValueByKey(key);
                        PackageProperty packageProperty = CreatePackageProperty(platform, packageSuiteName, type, packageSuiteSetup);
                        if (packageProperty == null)
                        {
                            string typeValue = packageSuiteSetup.GetSelectedValueByKeyAsString(key);
                            string msg = $"ERROR: No PropertyPackage definition found for property type: ";
                            msg += $"{Debug.FormatTextInUserContext(key)} and  value: {Debug.FormatTextInUserContext(typeValue)} ";
                            msg += $"when generating {Debug.FormatTextInUserContext(packageSuiteName)} package suite. ";

                            string methodName = $"{AppSpaceBuildSuiteProvider.CONSUMER_PACKAGE_SUITE_BUILDER_SHORT_TYPENAME}.CreatePackageProperty()";
                            msg += $" Make sure that the method {Debug.FormatTextInUserContext(methodName)} has a definition for such property ";
                            methodName = $"{AppSpaceBuildSuiteProvider.CONSUMER_PACKAGE_SUITE_BUILDER_SHORT_TYPENAME}.GetPackageSuiteSetup()";
                            msg += $" otherwise delete this property from {Debug.FormatTextInUserContext(methodName)} if you don't need it";
                            Debug.EditorLogError(msg);
                        }
                        else
                        {
                            packageSuiteSetup.RegisterProperty(type, valueIndex, packageProperty);
                            returnValue.AddProperty(packageProperty);
                        }
                    }

                    returnValue.PackageSuiteSetup = packageSuiteSetup;
                }
            }
            else
            {
                Debug.EditorLogError($"ERROR: No package suite found for name: {packageSuiteName}");
            }

            return returnValue;
        }

        /// <summary>
        /// Create a <c>PackageSuiteSetup</c> object that contains the values for the setup properties defined for the suite called <c>packageSuiteName</c>
        /// </summary>
        /// <param name="packageSuiteName">Name of the suite to create the <c>PackageSuiteSetup</c> object for.</param>
        /// <returns>A <c>PackageSuiteSetup</c> object that contains the values for the setup properties defined for the suite called <c>packageSuiteName</c></returns>
        protected virtual PackageSuiteSetup GetPackageSuiteSetup(string packageSuiteName)
        {
            // Default implementation provided. This method hasn't been declared as abstract because this approach is not mandatory.
            // Consumers can implement GeneratePackageSuite() instead.
            return new PackageSuiteSetup(null, null);
        }

        /// <summary>
        /// Return the file name, without the extension, to use for the artifact generated when building.
        /// </summary>
        /// <param name="packageSuite"><c>PackageSuite</c> object that contains the properties to apply.</param>
        /// <param name="gameVersion">Game version to build.</param>
        /// <param name="pipelineJob">CICD pipeline job information. Populated ONLY for CICD builds.</param>
        /// <returns></returns>
        public virtual string GetBuildFileNameWithoutExtension(PackageSuite packageSuite, string gameVersion, PipelineJob pipelineJob)
        {
            string prefix = string.IsNullOrEmpty(m_buildNamePrefix) ? "" : $"{ m_buildNamePrefix}_";

            string returnValue = $"{prefix}{packageSuite.name}";
            if (!string.IsNullOrEmpty(gameVersion))
            {
                returnValue += $"_{gameVersion}";
            }

            if (m_addPipelineInfoAsSufix)
            {
                // Use encoded branch name instead of plain branch name in order to avoid trouble when copying the build file artifact around
                string branchName = pipelineJob.EncodedBranchName;
                if (!string.IsNullOrEmpty(branchName))
                {
                    returnValue += $"_{branchName}";
                }

                string buildNumber = pipelineJob.BuildNumber;
                if (!string.IsNullOrEmpty(buildNumber))
                {
                    returnValue += $"_{buildNumber}";
                }
            }

            return returnValue;
        }

        public PipelineJob GetPipelineJob()
        {
            EnvironmentVariables environmentVariables = GetEnvironmentVariables();
            return new PipelineJob(environmentVariables.BranchName, environmentVariables.BuildNumber);
        }        

        public EnvironmentVariables GetEnvironmentVariables()
        {
            return EnvironmentVariables.GetEnvironmentVariables(GetDefaultEnvironmentVariables());
        }

        protected virtual EnvironmentVariables GetDefaultEnvironmentVariables()
        {
            return new EnvironmentVariables();
        }

        #region property
        // -----------------------------------------------------------------------------------------------------------------------------------------------------
        // Property Types
        // -----------------------------------------------------------------------------------------------------------------------------------------------------
        public const string PROPERTY_TYPE_SUITE = "Suite";

        private PackageSuite CreatePackageSuite(string packageSuiteName)
        {
            string name = GetPropertyName(packageSuiteName, "", "");
            PackageSuite returnValue = PackageSuite.CreateInstanceWithParams(name);

            return returnValue;
        }

        /// <summary>
        /// Create a <c>PackageProperty</c> object that contains all properties required by the setup type passed in.
        /// </summary>
        /// <param name="platform">Platform to build for.</param>
        /// <param name="parentName">Name of this property's parent. Used to create this property's name so it conveys context.</param>
        /// <param name="type">Setup type to create the <c>PackageProperty</c> object for.</param>
        /// <param name="packageSuiteSetup"><c>PackageSuiteSetup</c> object that contains all setup property values since some setup properties
        /// need to know about other setup properties to create the appropriate properties.</param>
        /// <returns></returns>
        public virtual PackageProperty CreatePackageProperty(EPlatform platform, string parentName, Type type, PackageSuiteSetup packageSuiteSetup)
        {
            return null;
        }

        /// <summary>
        /// Create a <c>PackagePropertyComposite</c> object that can be used to nest other properties inside.
        /// </summary>
        /// <param name="parentName">Name of this property's parent. Used to create this property's name so it conveys context.</param>
        /// <param name="propertyName">Property name.</param>
        /// <returns></returns>
        public PackagePropertyComposite CreatePackagePropertyComposite(string parentName, string propertyName)
        {
            PackagePropertyComposite returnValue = ScriptableObject.CreateInstance<PackagePropertyComposite>();
            returnValue.name = GetPropertyName(parentName, "composite", propertyName);

            return returnValue;
        }

        /// <summary>
        /// Create a <c>UnityBuildProperty</c> object that can be used to set values in Unity PlayerSettings and BuildSettings.
        /// </summary>
        /// <param name="parentName">Name of this property's parent. Used to create this property's name so it conveys context.</param>
        /// <param name="propertyName">Property name.</param>
        /// <returns></returns>
        public UnityBuildProperty CreateUnityBuildProperty(string parentName, string propertyName)
        {
            return UnityBuildProperty.CreateInstanceWithParams(GetPropertyName(parentName, "unity", propertyName));
        }

        /// <summary>
        /// Create a <c>SchemeProperty</c> object that can be used to set some values that modify the suite purpose (debug, release, ...)
        /// </summary>
        /// <param name="parentName">Name of this property's parent. Used to create this property's name so it conveys context.</param>
        /// <param name="propertyName">Property name.</param>
        /// <returns></returns>
        public SchemeProperty CreateSchemeProperty(string parentName, string propertyName)
        {
            return SchemeProperty.CreateInstanceWithParams(GetPropertyName(parentName, "scheme", propertyName));
        }

        /// <summary>
        /// Create a <c>LoggerProperty</c> object that can be used to customise Hotel Logger package behaviour
        /// </summary>
        /// <param name="parentName">Name of this property's parent. Used to create this property's name so it conveys context.</param>
        /// <param name="propertyName">Property name.</param>
        /// <param name="channelslPresetRootUnityPath">Root Unity path ("Assets/...") to the folder that contains all ChannelsPreset objects.</param>
        /// <param name="channelsPresetName">Name of the file in <c>channelslPresetRootUnityPath</c> that was copied into this object</param>
        /// <returns></returns>
        public LoggerProperty CreateLoggerProperty(string parentName, string propertyName, string channelslPresetRootUnityPath = null, string channelsPresetName = null)
        {
            return LoggerProperty.CreateInstanceWithParams(GetPropertyName(parentName, "logger", propertyName), channelslPresetRootUnityPath, channelsPresetName);
        }

        /// <summary>
        /// Create a <c>PlatformBuildProperty_iOS</c> object that can be used to set some iOS native properties such as frameworks, info.plist properties, ...
        /// </summary>
        /// <param name="parentName">Name of this property's parent. Used to create this property's name so it conveys context.</param>
        /// <param name="propertyName">Property name.</param>
        /// <returns></returns>
        public PlatformBuildProperty_iOS CreatePlatformBuildProperty_iOS(string parentName, string propertyName)
        {
            return PlatformBuildProperty_iOS.CreateInstanceWithParams(GetPropertyName(parentName, "ios", propertyName));
        }

        /// <summary>
        /// Create a <c>AssetBuildProperty</c> object that can be used move some assets stored in Hotel/Assets folder into Assets folder so they can
        /// be included in the build.
        /// </summary>
        /// <param name="parentName">Name of this property's parent. Used to create this property's name so it conveys context.</param>
        /// <param name="propertyName">Property name.</param>
        /// <returns></returns>
        public AssetBuildProperty CreateAssetBuildProperty(string parentName, string propertyName)
        {
            return AssetBuildProperty.CreateInstanceWithParams(GetPropertyName(parentName, "assets", propertyName));
        }

        /// <summary>
        /// Create a <c>FirebaseBuildProperty</c> object that can be used to ease the management of the Firebase Manifest file along with
        /// all files automatically generated by Firebase Editor component.
        /// </summary>
        /// <param name="srcManifestUnityPath">Unity path where the Firebase Manifest is located inside a 'Hotel/Assets' folder.</param>
        /// <param name="enableAnalyticsFullMode">Pass in <c>true</c> is you want to be able to report all events to Firebase Analytics
        ///                                       when Hotel FirebaseAnalytics package is installed. Otherwise only 'install' event (first_open)
        ///                                       will be reported. Please, get Legal's approval befor enabling Analytics full mode,.</param>
        /// <returns></returns>
        public FirebaseBuildProperty CreateFirebaseBuildProperty(string parentName, string propertyName, string srcManifestUnityPath, bool enableAnalyticsFullMode = false)
        {
            return FirebaseBuildProperty.CreateInstanceWithParams(GetPropertyName(parentName, "firebase", propertyName), srcManifestUnityPath, enableAnalyticsFullMode);
        }

        /// <summary>
        /// Create a <c>SocialBuildProperty</c> object that can be used to ease the management of Orion SocialCore.PlayGames package.
        /// </summary>
        /// <param name="srcGamesIdsUnityPath">Unity path where game-ids.xml is located inside a 'Hotel/Assets' folder.</param>
        /// <returns></returns>
        public SocialCoreBuildProperty CreateSocialCoreBuildProperty(string parentName, string propertyName, string srcGamesIdsUnityPath)
        {
            return SocialCoreBuildProperty.CreateInstanceWithParams(GetPropertyName(parentName, "socialCore", propertyName), srcGamesIdsUnityPath);
        }

        /// <summary>
        /// Create an <c>AppNameProperty</c> object that can be used to localise the app name.
        /// </summary>
        /// <param name="parentName">Name of this property's parent. Used to create this property's name so it conveys context.</param>
        /// <param name="propertyName">Property name.</param>
        /// <returns></returns>
        public AppNameProperty CreateAppNameProperty(string parentName, string propertyName)
        {
            return AppNameProperty.CreateInstanceWithParams(GetPropertyName(parentName, "appName", propertyName));
        }

        /// <summary>
        /// Create an <c>AddressablesBuildProperty</c> object that can be used to customise the way Addressables behave.
        /// </summary>
        /// <param name="parentName">Name of this property's parent. Used to create this property's name so it conveys context.</param>
        /// <param name="propertyName">Property name.</param>
        /// <param name="useAllInstallTime">.When <c>true</c> remote asset bundles are treated as if they were local.
        /// <param name="useStoreCdn">When <c>true</c> remote asset bundles are downloaded from the store CDN. Otherwise the app is responsible
        /// for storing the asset bundles in their own CDN.</param>               
        /// Use this mode when you don't want to push remote asset bundles to a CDN.</param>
        /// <param name="remoteHostSettings">.Use this parameter only when <c>useStoreCdn</c> is <c>true</c> and the app is using
        /// Ubisoft Cloud to store its remote asset bundles.
        /// <returns></returns>
        public AddressablesBuildProperty CreateAddressablesBuildProperty(string parentName, string propertyName, bool useAllInstallTime = false,
            bool useStoreCdn = false, AddressablesBuildProperty.RemoteHostSettings remoteHostSettings = null)
        {
            AddressablesBuildProperty returnValue = AddressablesBuildProperty.CreateInstanceWithParams(GetPropertyName(parentName, "addressables", propertyName));
            returnValue.UseAllInstallTime = useAllInstallTime ? PackageProperty.EBoolean.True : PackageProperty.EBoolean.False;
            returnValue.UseStoreCdn = useStoreCdn ? PackageProperty.EBoolean.True : PackageProperty.EBoolean.False;
            returnValue.HostSettings = remoteHostSettings;

            return returnValue;
        }

        /// <summary>
        /// Add a <c>UpmBuildProperty</c> object to <c>property</c> to add a particular implementation of a particular version of a package.
        /// </summary>
        /// <param name="property"><c>PackagePropertyComposite</c> object where to add this package to.</param>
        /// <param name="packageName">Package name to add (i.e. "com.ubisoft.hotel.console")</param>
        /// <param name="packageVersion">Package version to add (i.e. "0.0.1")</param>
        /// <param name="implementation">Implementation of the package to select in case the package supports several implementations.
        /// Hotel packages might have different implementations available. Look up the package documentation to find out what implementations are available.
        /// Use PackageDefinition.EImplementation.Prod for non-Hotel packages and for Hotel packages which documentation don't mention alternative implementations.</param>
        public bool AddPackageProperty(PackagePropertyComposite property, string packageName, string packageVersion = null,
                                PackageDefinition.EImplementation implementation = PackageDefinition.EImplementation.Prod)
        {
            bool returnValue = m_packages.ContainsKey(packageName);

            if (returnValue)
            {
                // Use default version if packageVersion is not provided
                if (string.IsNullOrEmpty(packageVersion))
                {
                    packageVersion = m_packages[packageName];
                }

                property.AddPackage(packageName, packageVersion, implementation);
            }

            return returnValue;
        }

        public string GetPropertyName(string parentName, string propertyType, string propertyName)
        {
            string returnValue = "";

            if (!string.IsNullOrEmpty(parentName))
            {
                returnValue = parentName;
            }

            if (!string.IsNullOrEmpty(propertyType))
            {
                if (returnValue.Length > 0)
                {
                    returnValue += ":";
                }

                returnValue += propertyType;
            }

            if (!string.IsNullOrEmpty(propertyName))
            {
                if (returnValue.Length > 0)
                {
                    returnValue += ":";
                }

                returnValue += propertyName;
            }

            return returnValue;
        }
        #endregion
    }
}