// Copyright (C) Stichting Deltares 2023. 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.Linq;
using System.Linq.Expressions;
using Deltares.DamEngine.Data.Design;
using Deltares.DamEngine.Data.General.Sensors.Specifications;
using Deltares.DamEngine.Data.General.Specifications.Extensions;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard;

namespace Deltares.DamEngine.Data.General.Sensors;

/// <summary>
/// Association class for sensor data and a location
/// </summary>
public class SensorLocation
{
    /// <summary>
    /// Constructor is needed for XML deserialization
    /// </summary>
    public SensorLocation()
    {
        SourceTypePl1WaterLevelAtRiver = DataSourceTypeSensors.LocationData;
        SourceTypePl1WaterLevelAtPolder = DataSourceTypeSensors.LocationData;
    }

    /// <summary>
    /// Gets the PL line offset below dike top at river.
    /// </summary>
    public double PlLineOffsetBelowDikeTopAtRiver
    {
        get
        {
            return Location.PlLineOffsetBelowDikeTopAtRiver;
        }
    }

    /// <summary>
    /// Gets the PL line offset below dike top at polder.
    /// </summary>
    public double PlLineOffsetBelowDikeTopAtPolder
    {
        get
        {
            return Location.PlLineOffsetBelowDikeTopAtPolder;
        }
    }

    /// <summary>
    /// Gets the PL line offset below dike toe at polder.
    /// </summary>
    public double PlLineOffsetBelowDikeToeAtPolder
    {
        get
        {
            return Location.PlLineOffsetBelowDikeToeAtPolder;
        }
    }

    /// <summary>
    /// Gets the PL line offset dry below shoulder base inside.
    /// </summary>
    public double PlLineOffsetDryBelowShoulderBaseInside
    {
        get
        {
            return Location.PlLineOffsetBelowShoulderBaseInside;
        }
    }

    /// <summary>
    /// Gets or sets the DAM location.
    /// </summary>
    /// <value>
    /// The location.
    /// </value>
    public Location Location { get; set; }

    /// <summary>
    /// Gets the location Name.
    /// </summary>
    /// <remarks>
    /// If the Name is empty it could indicate that there is no reference 
    /// to a valid location
    /// </remarks>
    public string LocationName
    {
        get
        {
            return (Location != null) ? Location.Name : string.Empty;
        }
    }

    /// <summary>
    /// Gets or sets the sensor sensorGroup.
    /// </summary>
    /// <value>
    /// The sensorGroup.
    /// </value>
    public SensorGroup SensorGroup { get; set; }

    /// <summary>
    /// Gets the sensorGroup ID. 
    /// </summary>
    /// <remarks>
    /// If the ID has value -1 then the there is no valid reference (null) 
    /// or the sensorGroup is transient. 
    /// </remarks>
    public int GroupId
    {
        get
        {
            if (SensorGroup == null)
            {
                return -1;
            }

            return SensorGroup.ID;
        }
    }

    /// <summary>
    /// Gets the sensor selection.
    /// </summary>
    public IEnumerable<Sensor> Sensors
    {
        get
        {
            if (SensorGroup == null)
            {
                return new Sensor[0];
            }

            return SensorGroup.Selection;
        }
    }

    /// <summary>
    /// Gets or sets the Pl3 data source type.
    /// </summary>
    /// <value>
    /// The Pl3.
    /// </value>
    public DataSourceTypeSensors SourceTypePl3 { get; set; }

    /// <summary>
    /// Gets or sets the Pl4 data source type.
    /// </summary>
    /// <value>
    /// The Pl4.
    /// </value>
    public DataSourceTypeSensors SourceTypePl4 { get; set; }

    /// <summary>
    /// Gets or sets the outer water level data source type.
    /// </summary>
    /// <value>
    /// The outer water level.
    /// </value>
    public DataSourceTypeSensors SourceTypePl1WaterLevelAtRiver { get; set; }

    /// <summary>
    /// Gets or sets the Pl1 PL line offset below dike top at river data source type.
    /// </summary>
    /// <value>
    /// Data source type for Pl1 PLLine offset below dike top at river.
    /// </value>
    public DataSourceTypeSensors SourceTypePl1PlLineOffsetBelowDikeTopAtRiver { get; set; }

    /// <summary>
    /// Gets or sets the Pl1 PL line offset below dike top at polder data source type
    /// </summary>
    /// <value>
    /// The Pl1 PL line offset below dike top at polder.
    /// </value>
    public DataSourceTypeSensors SourceTypePl1PlLineOffsetBelowDikeTopAtPolder { get; set; }

    /// <summary>
    /// Gets or sets the Pl1 PL line offset below shoulder base inside data source type
    /// </summary>
    /// <value>
    /// The Pl1 PL line offset below shoulder base inside.
    /// </value>
    public DataSourceTypeSensors SourceTypePl1PlLineOffsetBelowShoulderBaseInside { get; set; }

    /// <summary>
    /// Gets or sets the Pl1 PL line offset below dike toe at polder data source type.
    /// </summary>
    /// <value>
    /// The Pl1 PL line offset below dike toe at polder.
    /// </value>
    public DataSourceTypeSensors SourceTypePl1PlLineOffsetBelowDikeToeAtPolder { get; set; }

    /// <summary>
    /// Gets or sets the Pl1 polder level data source type.
    /// </summary>
    /// <value>
    /// The Pl1 polder level.
    /// </value>
    public DataSourceTypeSensors SourceTypePl1WaterLevelAtPolder { get; set; }

    /// <summary>
    /// Gets the sensor count.
    /// </summary>
    public int SensorCount
    {
        get
        {
            return SensorGroup == null ? 0 : SensorGroup.SensorCount;
        }
    }

    /// <summary>
    /// Gets the surface line.
    /// </summary>
    /// <value>
    /// The surface line.
    /// </value>
    public SurfaceLine2 SurfaceLine
    {
        get
        {
            return Location.SurfaceLine;
        }
    }

    /// <summary>
    /// Gets the river level.
    /// </summary>
    /// <value>
    /// The river level.
    /// </value>
    public double RiverLevel
    {
        get
        {
            return Location.RiverLevel;
        }
    }

    private DesignScenario CurrentScenario
    {
        get
        {
            var scenario = Location.CurrentScenario;
            if (scenario == null)
            {
                scenario = Location.Scenarios[0];
            }

            return scenario;
        }
    }
    
    /// <summary>
    /// Gets the polder level.
    /// </summary>
    /// <value>
    /// The polder level.
    /// </value>
    public double PolderLevel
    {
        get
        {
            return CurrentScenario.PolderLevel;
        }
    }

    /// <summary>
    /// Gets the head PL3.
    /// </summary>
    /// <value>
    /// The head PL3.
    /// </value>
    public double? HeadPl3
    {
        get
        {
            return CurrentScenario.HeadPl3;
        }
    }

    public double? HeadPl4
    {
        get
        {
            return CurrentScenario.HeadPl4;
        }
    }

    /// <summary>
    /// Gets or sets the profile.
    /// </summary>
    /// <value>
    /// The profile.
    /// </value>
    public string Profile
    {
        get; //{ return SoilProfile2D } ;
        set;
    }

    /// <summary>
    /// Gets or sets the MStab file.
    /// </summary>
    /// <value>
    /// The MStab file.
    /// </value>
    public string MStabFile
    {
        get; //{ return SoilProfile2D } ;
        set;
    }

    /// <summary>
    /// Holds a reference to a dictionary of output date time entries
    /// The keys represent the time step and the value part of the dictionary represents 
    /// the argument for the calculation
    /// 
    /// TimeStep -> Location -> (Sensor, Value)
    /// 
    /// Cardinality:
    ///     1    ->     N    ->      M 
    /// </summary>
    public IDictionary<DateTime, IDictionary<Location, IDictionary<Sensor, double>>> SensorValues { get; set; }

    /// <summary>
    /// Gets or sets the GetGroups function (injectable list, for UI purposes).
    /// </summary>
    /// <value>
    /// The list of available Groups.
    /// </value>
    public static Func<SensorLocation, IEnumerable<SensorGroup>> GetGroups { get; set; }

    /// <summary>
    /// Gets the PiezometricHead type sensors sorted by relative location along profile.
    /// </summary>
    /// <param name="plLineType">Type of the pl line.</param>
    /// <returns></returns>
    public SortedDictionary<double, Sensor> GetSensorsSortedByRelativeLocationAlongProfile(PlLineType plLineType)
    {
        IDictionary<Sensor, double> calculatedRelativeLocations = BuildRelativeLocationTable();

        var table = new SortedDictionary<double, Sensor>();

        // leave out the water level and polder level sensors
        IEnumerable<Sensor> candidateSensors =
            Sensors.GetBySpecification(new PiezometricHeadSensorSpecification());

        foreach (Sensor sensor in candidateSensors)
        {
            if (sensor.PlLineMappings.Contains(plLineType))
            {
                double relativeLocation = sensor.RelativeLocationSpecified ? sensor.RelativeLocation : calculatedRelativeLocations[sensor];

                if (table.ContainsKey(relativeLocation))
                {
                    throw new InvalidOperationException(
                        "Error creating lookup table with sensors sorted by relative location along profile. The x-location " + relativeLocation + " already exists. Sensor " + sensor);
                }

                table.Add(relativeLocation, sensor);
            }
        }

        return table;
    }

    /// <summary>
    /// Gets the sensor value.
    /// </summary>
    /// <param name="expression">The expression.</param>
    /// <param name="sensorValues">The sensor values.</param>
    /// <param name="sensor">The sensor.</param>
    /// <returns></returns>
    /// <exception cref="System.ArgumentNullException">
    /// sensorValues
    /// or
    /// sensor
    /// </exception>
    /// <exception cref="System.ArgumentException">The given sensor is not an item/key in the table of sensor values</exception>
    public double? GetValue(Expression<Func<SensorLocation, object>> expression, IDictionary<Sensor, double> sensorValues, Sensor sensor)
    {
        if (sensorValues == null)
        {
            throw new ArgumentNullException("sensorValues");
        }

        if (sensor == null)
        {
            throw new ArgumentNullException("sensor");
        }

        if (!sensorValues.ContainsKey(sensor))
        {
            throw new ArgumentException("The given sensor is not an item/key in the table of sensor values");
        }

        string memberName = StaticReflection.GetMemberName(expression);

        if (memberName == MemberNames.OffsetBelowDikeToeAtPolder)
        {
            if (SourceTypePl1PlLineOffsetBelowDikeToeAtPolder == DataSourceTypeSensors.LocationData)
            {
                return Location.PlLineOffsetBelowDikeToeAtPolder;
            }
        }

        if (memberName == MemberNames.OffsetBelowDikeTopAtPolder)
        {
            if (SourceTypePl1PlLineOffsetBelowDikeTopAtPolder == DataSourceTypeSensors.LocationData)
            {
                return Location.PlLineOffsetBelowDikeTopAtPolder;
            }
        }

        if (memberName == MemberNames.OffsetBelowDikeTopAtRiver)
        {
            if (SourceTypePl1PlLineOffsetBelowDikeTopAtRiver == DataSourceTypeSensors.LocationData)
            {
                return Location.PlLineOffsetBelowDikeTopAtRiver;
            }
        }

        if (memberName == MemberNames.OffsetBelowShoulderBaseInside)
        {
            if (SourceTypePl1PlLineOffsetBelowShoulderBaseInside == DataSourceTypeSensors.LocationData)
            {
                return Location.PlLineOffsetBelowShoulderBaseInside;
            }
        }

        if (memberName == MemberNames.WaterLevelAtRiver)
        {
            if (SourceTypePl1WaterLevelAtRiver == DataSourceTypeSensors.LocationData)
            {
                return Location.RiverLevel;
            }

            if (SourceTypePl1WaterLevelAtRiver == DataSourceTypeSensors.Sensor)
            {
                return sensorValues[sensor];
            }
        }

        if (memberName == MemberNames.PolderLevel)
        {
            if (SourceTypePl1WaterLevelAtPolder == DataSourceTypeSensors.LocationData)
            {
                return CurrentScenario.PolderLevel;
            }

            if (SourceTypePl1WaterLevelAtPolder == DataSourceTypeSensors.Sensor)
            {
                return sensorValues[sensor];
            }
        }

        if (memberName == MemberNames.Pl3)
        {
            if (SourceTypePl3 == DataSourceTypeSensors.LocationData)
            {
                return CurrentScenario.HeadPl3;
            }

            if (SourceTypePl3 == DataSourceTypeSensors.Sensor)
            {
                return sensorValues[sensor];
            }
        }

        if (memberName == MemberNames.Pl4)
        {
            if (SourceTypePl4 == DataSourceTypeSensors.LocationData)
            {
                return CurrentScenario.HeadPl4;
            }

            if (SourceTypePl4 == DataSourceTypeSensors.Sensor)
            {
                return sensorValues[sensor];
            }
        }

        return null;
    }

    /// <summary>
    /// Builds the relative location table.
    /// </summary>
    /// <returns></returns>
    internal IDictionary<Sensor, double> BuildRelativeLocationTable()
    {
        GeometryPoint surfaceLevelOutside = SurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelOutside);
        if (surfaceLevelOutside == null)
        {
            throw new InvalidOperationException("No SurfaceLevelOutside point on surface line defined");
        }

        double startPoint = surfaceLevelOutside.X;

        var dict = new Dictionary<Sensor, double>();
        foreach (Sensor sensor in Sensors)
        {
            double relativeLocation = startPoint + (Location.XRdDikeLine - sensor.XRd);
            dict.Add(sensor, relativeLocation);
        }

        return dict;
    }

    internal static class MemberNames
    {
        internal static readonly string OffsetBelowDikeToeAtPolder = StaticReflection.GetMemberName<SensorLocation>(x => x.SourceTypePl1PlLineOffsetBelowDikeToeAtPolder);
        internal static readonly string OffsetBelowDikeTopAtPolder = StaticReflection.GetMemberName<SensorLocation>(x => x.SourceTypePl1PlLineOffsetBelowDikeTopAtPolder);
        internal static readonly string OffsetBelowDikeTopAtRiver = StaticReflection.GetMemberName<SensorLocation>(x => x.SourceTypePl1PlLineOffsetBelowDikeTopAtRiver);
        internal static readonly string OffsetBelowShoulderBaseInside = StaticReflection.GetMemberName<SensorLocation>(x => x.SourceTypePl1PlLineOffsetBelowShoulderBaseInside);
        internal static readonly string WaterLevelAtRiver = StaticReflection.GetMemberName<SensorLocation>(x => x.SourceTypePl1WaterLevelAtRiver);
        internal static readonly string PolderLevel = StaticReflection.GetMemberName<SensorLocation>(x => x.SourceTypePl1WaterLevelAtPolder);
        internal static readonly string Pl3 = StaticReflection.GetMemberName<SensorLocation>(x => x.SourceTypePl3);
        internal static readonly string Pl4 = StaticReflection.GetMemberName<SensorLocation>(x => x.SourceTypePl4);
    }
}