// Copyright (C) Stichting Deltares 2024. All rights reserved.
// 
// This file is part of the Dam Engine.
// 
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
// 
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// 
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Xml.Linq;

namespace Deltares.DamEngine.Calculators.KernelWrappers.Assemblers;

#region DtoAssembler<TDomainObject, TDataTransferObject> definition

/// <summary>
/// Default implementation for the <see cref="IDtoAssembler"/> interface
/// </summary>
/// <typeparam name="T">The domain object type</typeparam>
public abstract class DtoAssembler<TDomainObject, TDataTransferObject> : IDtoAssembler<TDomainObject, TDataTransferObject>
    where TDomainObject : new()
{
    /// <summary>
    /// Holds the property mappings
    /// </summary>
    private readonly DtoPropertyAttributeMap map = new DtoPropertyAttributeMap();

    /// <summary>
    /// Gets the property mappings collection
    /// </summary>
    protected DtoPropertyAttributeMap Mappings
    {
        get
        {
            return map;
        }
    }

    /// <summary>
    /// 
    /// </summary>
    protected void InitializeMappings()
    {
        var tmp = new TDomainObject();
        map.AddOrUpdateRange(tmp.ToPropertyMap());
    }

    /// <summary>
    ///
    /// </summary>
    protected void InitializeMappings(string elementName, XDocument xsdReferenceDocument)
    {
        var tmp = new TDomainObject();
        IEnumerable<DtoPropertyAttributeMapping> tmpMap = tmp.ToPropertyMap(elementName, xsdReferenceDocument);
        map.AddOrUpdateRange(tmpMap);
    }

    /// <summary>
    /// Adds or updates a property-to-attribute mapping item into the property map
    /// </summary>
    /// <param name="propertyName">The name of the property</param>
    /// <param name="attributeName">The name of the attribute to map to</param>
    protected void AddOrUpdateMapping(string propertyName, string attributeName)
    {
        AddOrUpdateMapping(propertyName, attributeName, DtoPropertyImportance.Optional);
    }

    /// <summary>
    /// Adds or updates a property-to-attribute mapping item into the property map
    /// </summary>
    /// <param name="propertyName">The name of the property</param>
    /// <param name="attributeName">The name of the attribute to map to</param>
    /// <param name="importance">The usage or importance of the value i.e. reguired or optional</param>
    protected void AddOrUpdateMapping(string propertyName, string attributeName, DtoPropertyImportance importance)
    {
        if (!propertyName.HasValidStringValue())
        {
            throw new DtoPropertyMapException("propertyName is not valid (empty or null)");
        }

        bool q = (from x in new TDomainObject().GetType().GetProperties()
                  where x.Name == propertyName
                  select x).Any();

        if (!q)
        {
            throw new DtoPropertyMapException("The property you want to add or update doesnt exist in the property list of the domain object.");
        }

        Mappings.AddOrUpdate(propertyName, attributeName, importance);
    }

    #region IDtoAssembler<TDomainObject,TDataTransferObject> Members

    /// <summary>
    /// 
    /// </summary>
    /// <param name="dtoObj"></param>
    /// <returns></returns>
    public abstract TDomainObject CreateDomainObject(TDataTransferObject dtoObj);

    /// <summary>
    /// 
    /// </summary>
    /// <param name="domainObj"></param>
    /// <returns></returns>
    public abstract TDataTransferObject CreateDataTransferObject(TDomainObject domainObj);

    #endregion
}

#endregion

#region DtoAssembler<TDomainObject, XElement>

/// <summary>
/// Default implementation for the <see cref="IDtoAssembler"/> interface
/// </summary>
/// <remarks>
/// This base class inherits from <see cref="DtoAssembler"/> this class just fixes 
/// the dto type to XElement
/// </remarks>
/// <typeparam name="T">The domain object type</typeparam>
public abstract class DtoAssembler<TDomainObject> : DtoAssembler<TDomainObject, XElement>, IDtoAssembler<TDomainObject>
    where TDomainObject : new()
{
    /// <summary>
    /// Initializes a new instance of the DtoAssembler class
    /// </summary>
    /// <param name="elementName">Sets the element name</param>
    /// <param name="xsdStream">The text reader stream for reading in ther xsd file which is embedded as an resource</param>
    public DtoAssembler(string elementName, Stream xsdStream)
        : this(elementName, null, xsdStream) {}

    /// <summary>
    /// Initializes a new instance of the DtoAssembler class
    /// </summary>
    /// <param name="elementName">Sets the element name</param>
    /// <param name="xsdStream">The text reader stream for reading in ther xsd file which is embedded as an resource</param>
    public DtoAssembler(string elementName, string elementNamespace)
        : this(elementName, elementNamespace, null) {}

    /// <summary>
    /// Initializes a new instance of the DtoAssembler class
    /// </summary>
    /// <param name="elementName">Sets the element name</param>
    /// <param name="xsdStream">The text reader stream for reading in ther xsd file which is embedded as an resource</param>
    public DtoAssembler(string elementName, string elementNamespace, Stream xsdStream)
    {
        ElementName = elementName;
        ElementNamespace = elementNamespace;

        if (xsdStream == null)
        {
            xsdStream = GetXsdStreamFromEmbeddedResource();
        }

        XDocument doc = XDocument.Load(new StreamReader(xsdStream));
        Schema = doc;
        InitializeMappings(elementName, doc);
    }

    /// <summary>
    /// Gets or sets the namespace value for the element
    /// </summary>
    public string ElementNamespace { get; }

    /// <summary>
    /// Gets the xml schema (if any)
    /// </summary>
    public XDocument Schema { get; }

    public Stream GetXsdStreamFromEmbeddedResource()
    {
        if (string.IsNullOrEmpty(ElementNamespace))
        {
            return null;
        }

        Assembly assembly = GetType().Assembly;
        string schemaName = ElementNamespace.Substring(ElementNamespace.LastIndexOf('/') + 1);
        schemaName += schemaName.EndsWith(".xsd") ? "" : ".xsd";

        string resourceName = (from string name in assembly.GetManifestResourceNames()
                               where name.EndsWith(schemaName)
                               select name).Single();

        return assembly.GetEmbeddedFile(resourceName);
    }

    public virtual TDomainObject CreateDomainObject(XDocument dtoDocument)
    {
        if (dtoDocument == null)
        {
            throw new ArgumentNullException("dtoDocument");
        }

        XElement el = null;
        el = (from x in dtoDocument.Descendants()
              where x.Name.LocalName == ElementName
              select x).Single();

        return CreateDomainObject(el);
    }

    #region IDtoAssembler<TDomainObject> Members

    /// <summary>
    /// Gets the xml element name
    /// </summary>
    public string ElementName { get; }

    /// <summary>
    /// Creates and materialized a data tranfer object (dto) from a domain object
    /// </summary>
    /// <param name="domainObj">The domain object</param>
    /// <returns>An XElement instance</returns>
    public override XElement CreateDataTransferObject(TDomainObject domainObj)
        
    {
        if (!typeof(TDomainObject).IsValueType && (domainObj == null))
        {
            return null;
        }

        if (!ElementName.HasValidStringValue())
        {
            throw new DtoAssemblerException("There is no element name specified");
        }

        if (ElementNamespace.HasValidStringValue())
        {
            XNamespace ns = ElementNamespace;
            return new XElement(ns + ElementName)
                .Materialize(domainObj, Mappings);
        }

        return new XElement(ElementName)
            .Materialize(domainObj, Mappings);
    }

    /// <summary>
    /// Creates and materializes a domain object from a data tranfer object (dto)
    /// </summary>
    /// <param name="dtoObj">The dto object</param>
    /// <returns>The materialized domain object</returns>
    public override TDomainObject CreateDomainObject(XElement dto)
    {
        return new TDomainObject().Materialize(dto, Mappings);
    }

    #endregion
}

#endregion