// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using NuGet.Frameworks;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Microsoft.DotNet.Build.Tasks.Packaging
{
    public class PackageReport
    {
        public PackageReport()
        {
            Targets = new Dictionary<string, Target>();
        }
 
        public string Id { get; set; }
        public string Version { get; set; }
 
        public Dictionary<string, string> SupportedFrameworks { get; set; }
        public Dictionary<string,Target> Targets { get; set; }
        public PackageAsset[] UnusedAssets { get; set; }
 
        public void Save(string path)
        {
            string directory = Path.GetDirectoryName(path);
            if (!Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }
 
            using (var file = File.CreateText(path))
            {
                var serializer = new JsonSerializer();
                serializer.StringEscapeHandling = StringEscapeHandling.EscapeNonAscii;
                serializer.Formatting = Formatting.Indented;
                serializer.NullValueHandling = NullValueHandling.Ignore;
                serializer.DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate;
                serializer.Converters.Add(new VersionConverter());
                serializer.Converters.Add(new NuGetFrameworkConverter());
                serializer.Serialize(file, this);
            }
        }
 
        public static PackageReport Load(string path)
        {
            using (var file = File.OpenText(path))
            using (var jsonTextReader = new JsonTextReader(file))
            {
                var serializer = new JsonSerializer();
                serializer.Converters.Add(new VersionConverter());
                serializer.Converters.Add(new NuGetFrameworkConverter());
                return serializer.Deserialize<PackageReport>(jsonTextReader);
            }
        }
    }
 
    internal class NuGetFrameworkConverter : JsonConverter
    {
        public override bool CanConvert(Type objectType)
        {
            return objectType == typeof(NuGetFramework);
        }
 
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var lineInfo = reader as IJsonLineInfo;
            switch (reader.TokenType)
            {
                case JsonToken.Null:
                    return null;
                case JsonToken.String:
                    try
                    {
                        return NuGetFramework.Parse((string)reader.Value);
                    }
                    catch(Exception exception)
                    {
                        throw new JsonSerializationException($"Failed to parse {nameof(NuGetFramework)} {reader.Value}.  Line {lineInfo.LineNumber}, position {lineInfo.LinePosition}", exception);
                    }
                default:
                    throw new JsonSerializationException($"Unexpected token type {reader.TokenType} when parsing {nameof(NuGetFramework)}.  Line {lineInfo.LineNumber}, position {lineInfo.LinePosition}");
            }
        }
 
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value == null)
            {
                writer.WriteNull();
            }
            else if (value is NuGetFramework)
            {
                writer.WriteValue(value.ToString());
            }
            else
            {
                throw new JsonSerializationException($"Expected {nameof(NuGetFramework)} but got {value.GetType()}");
            }
        }
    }
 
    public class Target
    {
        private static readonly PackageAsset[] s_emptyPackageAsset = new PackageAsset[0];
        public Target()
        {
            CompileAssets = RuntimeAssets = NativeAssets = s_emptyPackageAsset;
        }
 
        public string Framework { get; set; }
        public string RuntimeID { get; set; }
 
        public PackageAsset[] CompileAssets { get; set; }
        public PackageAsset[] RuntimeAssets { get; set; }
        public PackageAsset[] NativeAssets { get; set; }
 
        public bool ShouldSerializeCompileAssets() { return CompileAssets != null && CompileAssets.Length != 0; }
        public bool ShouldSerializeRuntimeAssets() { return RuntimeAssets != null && RuntimeAssets.Length != 0; }
        public bool ShouldSerializeNativeAssets() { return NativeAssets != null && NativeAssets.Length != 0; }
    }
 
    public class PackageAsset
    {
        public string HarvestedFrom { get; set; }
        public string LocalPath { get; set; }
        public string PackagePath { get; set; }
        public BuildProject SourceProject { get; set; }
        public NuGetFramework TargetFramework { get; set;}
        public Version Version { get; set; }
    }
 
    public class BuildProject
    {
        public string Project { get; set; }
        public string AdditionalProperties { get; set; }
        public string UndefineProperties { get; set; }
 
        public override bool Equals(object other)
        {
            var otherProject = other as BuildProject;
 
            return otherProject != null &&
                    Project == otherProject.Project &&
                    AdditionalProperties == otherProject.AdditionalProperties &&
                    UndefineProperties == otherProject.UndefineProperties;
        }
 
        public override int GetHashCode()
        {
            var hash = Project.GetHashCode();
            hash ^= AdditionalProperties.GetHashCode();
            hash ^= UndefineProperties.GetHashCode();
            return hash;
        }
 
        public ITaskItem ToItem()
        {
            var item = new TaskItem(Project);
            item.SetMetadata(nameof(AdditionalProperties), AdditionalProperties);
            item.SetMetadata(nameof(UndefineProperties), UndefineProperties);
            return item;
        }
    }
}