// 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.Generic;
using Microsoft.Build.Framework;

namespace Microsoft.Build.BackEnd
{
    /// <summary>
    /// Response packet from owning worker node to TaskHost with BuildProjectFile* results.
    /// Carries the build success/failure and target outputs per project.
    /// </summary>
    internal class TaskHostBuildResponse : INodePacket, ITaskHostCallbackPacket
    {
        private int _requestId;
        private bool _success;

        /// <summary>
        /// Target outputs per project. Each entry is a dictionary mapping target names to TaskParameter
        /// wrapping ITaskItem[] outputs. Uses the same TaskParameter serialization as TaskHostTaskComplete.
        /// </summary>
        private List<Dictionary<string, TaskParameter>>? _targetOutputsPerProject;

        public TaskHostBuildResponse()
        {
        }

        public TaskHostBuildResponse(int requestId, bool success, List<Dictionary<string, TaskParameter>>? targetOutputsPerProject)
        {
            _requestId = requestId;
            _success = success;
            _targetOutputsPerProject = targetOutputsPerProject;
        }

        public NodePacketType Type => NodePacketType.TaskHostBuildResponse;

        public int RequestId
        {
            get => _requestId;
            set => _requestId = value;
        }

        /// <summary>Whether the build succeeded.</summary>
        public bool Success => _success;

        /// <summary>Per-project target outputs, or null if outputs were not requested.</summary>
        public List<Dictionary<string, TaskParameter>>? TargetOutputsPerProject => _targetOutputsPerProject;

        /// <summary>
        /// Reconstructs a <see cref="BuildEngineResult"/> from this response packet.
        /// Converts <see cref="TaskParameter"/> values back to <see cref="ITaskItem"/>[] arrays.
        /// </summary>
        public BuildEngineResult ToBuildEngineResult()
        {
            List<IDictionary<string, ITaskItem[]>>? result = null;

            if (_targetOutputsPerProject is not null)
            {
                result = new List<IDictionary<string, ITaskItem[]>>(_targetOutputsPerProject.Count);

                foreach (Dictionary<string, TaskParameter> projectOutputs in _targetOutputsPerProject)
                {
                    var dict = new Dictionary<string, ITaskItem[]>(projectOutputs.Count, StringComparer.OrdinalIgnoreCase);

                    if (projectOutputs is not null)
                    {
                        foreach (KeyValuePair<string, TaskParameter> entry in projectOutputs)
                        {
                            dict[entry.Key] = (ITaskItem[]?)entry.Value?.WrappedParameter ?? [];
                        }
                    }

                    result.Add(dict);
                }
            }

            return new BuildEngineResult(_success, result ?? []);
        }

        /// <summary>
        /// Creates a response from a <see cref="BuildEngineResult"/>.
        /// Wraps <see cref="ITaskItem"/>[] arrays in <see cref="TaskParameter"/> for serialization.
        /// </summary>
        internal static TaskHostBuildResponse FromBuildEngineResult(int requestId, BuildEngineResult engineResult)
        {
            List<Dictionary<string, TaskParameter>>? outputs = null;

            if (engineResult.TargetOutputsPerProject is not null && engineResult.TargetOutputsPerProject.Count > 0)
            {
                outputs = new List<Dictionary<string, TaskParameter>>(engineResult.TargetOutputsPerProject.Count);

                foreach (IDictionary<string, ITaskItem[]> projectOutputs in engineResult.TargetOutputsPerProject)
                {
                    var dict = new Dictionary<string, TaskParameter>(projectOutputs?.Count ?? 0, StringComparer.OrdinalIgnoreCase);

                    if (projectOutputs is not null)
                    {
                        foreach (KeyValuePair<string, ITaskItem[]> entry in projectOutputs)
                        {
                            dict[entry.Key] = new TaskParameter(entry.Value);
                        }
                    }

                    outputs.Add(dict);
                }
            }

            return new TaskHostBuildResponse(requestId, engineResult.Result, outputs);
        }

        public void Translate(ITranslator translator)
        {
            translator.Translate(ref _requestId);
            translator.Translate(ref _success);
            TranslateTargetOutputs(translator);
        }

        private void TranslateTargetOutputs(ITranslator translator)
        {
            bool hasOutputs = _targetOutputsPerProject is not null;
            translator.Translate(ref hasOutputs);

            if (!hasOutputs)
            {
                _targetOutputsPerProject = null;
                return;
            }

            int count = _targetOutputsPerProject?.Count ?? 0;
            translator.Translate(ref count);

            if (translator.Mode == TranslationDirection.ReadFromStream)
            {
                _targetOutputsPerProject = new List<Dictionary<string, TaskParameter>>(count);
                for (int i = 0; i < count; i++)
                {
                    Dictionary<string, TaskParameter>? dict = null;
                    translator.TranslateDictionary(ref dict, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization);
                    _targetOutputsPerProject.Add(dict!);
                }
            }
            else
            {
                for (int i = 0; i < count; i++)
                {
                    Dictionary<string, TaskParameter>? dict = _targetOutputsPerProject![i];
                    translator.TranslateDictionary(ref dict, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization);
                }
            }
        }

        internal static INodePacket FactoryForDeserialization(ITranslator translator)
        {
            var packet = new TaskHostBuildResponse();
            packet.Translate(translator);
            return packet;
        }
    }
}