// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System;
using System.Collections;
using System.Collections.Generic;
 
namespace Microsoft.Build.BackEnd
{
    /// <summary>
    /// Packet sent from TaskHost to owning worker node to execute a BuildProjectFile* callback.
    /// All four BuildProjectFile/BuildProjectFilesInParallel overloads normalize to the
    /// IBuildEngine3 6-param canonical form carried by this packet.
    /// </summary>
    internal class TaskHostBuildRequest : INodePacket, ITaskHostCallbackPacket
    {
        private int _requestId;
        private string[]? _projectFileNames;
        private string[]? _targetNames;
        private Dictionary<string, string>?[]? _globalProperties;
        private List<string>?[]? _removeGlobalProperties;
        private string[]? _toolsVersions;
        private bool _returnTargetOutputs;
 
        public TaskHostBuildRequest()
        {
        }
 
        public TaskHostBuildRequest(
            string[]? projectFileNames,
            string[]? targetNames,
            Dictionary<string, string>?[]? globalProperties,
            List<string>?[]? removeGlobalProperties,
            string[]? toolsVersions,
            bool returnTargetOutputs)
        {
            _projectFileNames = projectFileNames;
            _targetNames = targetNames;
            _globalProperties = globalProperties;
            _removeGlobalProperties = removeGlobalProperties;
            _toolsVersions = toolsVersions;
            _returnTargetOutputs = returnTargetOutputs;
        }
 
        public NodePacketType Type => NodePacketType.TaskHostBuildRequest;
 
        public int RequestId
        {
            get => _requestId;
            set => _requestId = value;
        }
 
        /// <summary>Array of project file paths to build.</summary>
        public string[]? ProjectFileNames => _projectFileNames;
 
        /// <summary>Array of target names to build in each project.</summary>
        public string[]? TargetNames => _targetNames;
 
        /// <summary>Per-project global properties to pass to the build.</summary>
        public Dictionary<string, string>?[]? GlobalProperties => _globalProperties;
 
        /// <summary>Per-project global properties to remove before building.</summary>
        public List<string>?[]? RemoveGlobalProperties => _removeGlobalProperties;
 
        /// <summary>Per-project tools versions to use.</summary>
        public string[]? ToolsVersions => _toolsVersions;
 
        /// <summary>Whether to include target outputs in the response.</summary>
        public bool ReturnTargetOutputs => _returnTargetOutputs;
 
        /// <summary>
        /// Converts non-generic IDictionary[] (as used by IBuildEngine interfaces) to
        /// Dictionary&lt;string, string&gt;[] for serialization.
        /// </summary>
        internal static Dictionary<string, string>?[]? ConvertGlobalProperties(IDictionary[]? globalProperties)
        {
            if (globalProperties is null)
            {
                return null;
            }
 
            var result = new Dictionary<string, string>?[globalProperties.Length];
            for (int i = 0; i < globalProperties.Length; i++)
            {
                if (globalProperties[i] is not null)
                {
                    result[i] = new Dictionary<string, string>(globalProperties[i].Count, StringComparer.OrdinalIgnoreCase);
                    foreach (DictionaryEntry entry in globalProperties[i])
                    {
                        result[i]![(string)entry.Key] = entry.Value?.ToString() ?? string.Empty;
                    }
                }
            }
 
            return result;
        }
 
        /// <summary>
        /// Converts IList&lt;string&gt;[] to List&lt;string&gt;[] for serialization.
        /// </summary>
        internal static List<string>?[]? ConvertRemoveGlobalProperties(IList<string>[]? removeGlobalProperties)
        {
            if (removeGlobalProperties is null)
            {
                return null;
            }
 
            return Array.ConvertAll(removeGlobalProperties,
                list => list is not null ? new List<string>(list) : null);
        }
 
        public void Translate(ITranslator translator)
        {
            translator.Translate(ref _requestId);
            TranslateNullableStringArray(translator, ref _projectFileNames);
            TranslateNullableStringArray(translator, ref _targetNames);
            translator.Translate(ref _returnTargetOutputs);
            TranslateNullableStringArray(translator, ref _toolsVersions);
            TranslateGlobalPropertiesArray(translator);
            TranslateRemoveGlobalPropertiesArray(translator);
        }
 
        /// <summary>
        /// Serializes a string array where individual elements may be null.
        /// The standard translator.Translate(ref string[]) doesn't handle null elements.
        /// </summary>
        private static void TranslateNullableStringArray(ITranslator translator, ref string[]? array)
        {
            bool hasArray = array is not null;
            translator.Translate(ref hasArray);
 
            if (!hasArray)
            {
                array = null;
                return;
            }
 
            int length = array?.Length ?? 0;
            translator.Translate(ref length);
 
            if (translator.Mode == TranslationDirection.ReadFromStream)
            {
                array = new string[length];
            }
 
            for (int i = 0; i < length; i++)
            {
                string? element = array![i];
                translator.Translate(ref element);
                array[i] = element!;
            }
        }
 
        private void TranslateGlobalPropertiesArray(ITranslator translator)
        {
            bool hasArray = _globalProperties is not null;
            translator.Translate(ref hasArray);
 
            if (!hasArray)
            {
                _globalProperties = null;
                return;
            }
 
            int length = _globalProperties?.Length ?? 0;
            translator.Translate(ref length);
 
            if (translator.Mode == TranslationDirection.ReadFromStream)
            {
                _globalProperties = new Dictionary<string, string>?[length];
            }
 
            for (int i = 0; i < length; i++)
            {
                Dictionary<string, string>? dict = _globalProperties![i];
                translator.TranslateDictionary(ref dict, StringComparer.OrdinalIgnoreCase);
                _globalProperties[i] = dict;
            }
        }
 
        private void TranslateRemoveGlobalPropertiesArray(ITranslator translator)
        {
            bool hasArray = _removeGlobalProperties is not null;
            translator.Translate(ref hasArray);
 
            if (!hasArray)
            {
                _removeGlobalProperties = null;
                return;
            }
 
            int length = _removeGlobalProperties?.Length ?? 0;
            translator.Translate(ref length);
 
            if (translator.Mode == TranslationDirection.ReadFromStream)
            {
                _removeGlobalProperties = new List<string>?[length];
            }
 
            for (int i = 0; i < length; i++)
            {
                List<string>? list = _removeGlobalProperties![i];
                translator.Translate(ref list);
                _removeGlobalProperties[i] = list;
            }
        }
 
        internal static INodePacket FactoryForDeserialization(ITranslator translator)
        {
            var packet = new TaskHostBuildRequest();
            packet.Translate(translator);
            return packet;
        }
    }
}