// 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 Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.PlLines;
using Deltares.DamEngine.Data.General.Sensors;

namespace Deltares.DamEngine.Calculators.PlLinesCreator
{
    internal class SensorPlLineCreator
    {
        private readonly IDictionary<PlLineType, IPlLineCreator> creators = new Dictionary<PlLineType, IPlLineCreator>();

        /// <summary>
        /// Initializes a new instance of the <see cref="SensorPlLineCreator"/> class.
        /// </summary>
        /// <param name="creator">The 'concrete' creator.</param>
        /// <param name="type">The type.</param>
        public SensorPlLineCreator(IPlLineCreator creator, PlLineType type)
        {
            creators.Add(type, creator);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SensorPlLineCreator"/> class.
        /// </summary>
        /// <param name="creators">The 'concrete' creators.</param>
        public SensorPlLineCreator(IEnumerable<Tuple<PlLineType, IPlLineCreator>> creators)
        {
            foreach (Tuple<PlLineType, IPlLineCreator> creator in creators)
            {
                this.creators.Add(creator.Item1, creator.Item2);
            }
        }

        /// <summary>
        /// Creates an instance of a SensorPlLineCreator for Pl1. Pl3, Pl4.
        /// </summary>
        /// <param name="sensorLocation">The sensor location.</param>
        /// <param name="sensorValues">The sensor values.</param>
        /// <returns></returns>
        public static SensorPlLineCreator CreateInstance(SensorLocation sensorLocation, IDictionary<Sensor, double> sensorValues)
        {
            return CreateInstance(sensorLocation, sensorValues, new[]
            {
                PlLineType.Pl1,
                PlLineType.Pl3,
                PlLineType.Pl4,
            });
        }

        /// <summary>
        /// Creates an instance of a SensorPlLineCreator.
        /// </summary>
        /// <param name="sensorLocation">The sensor location.</param>
        /// <param name="sensorValues">The sensor values.</param>
        /// <param name="lineTypes"> </param>
        /// <returns></returns>
        public static SensorPlLineCreator CreateInstance(SensorLocation sensorLocation, IDictionary<Sensor, double> sensorValues, IEnumerable<PlLineType> lineTypes)
        {
            IPlLineCreator c1 = new SensorPlLine1Creator(sensorLocation, sensorValues);
            IPlLineCreator c3 = new SensorPlLine3Creator(sensorLocation, sensorValues);
            IPlLineCreator c4 = new SensorPlLine4Creator(sensorLocation, sensorValues);

            var tuples = new List<Tuple<PlLineType, IPlLineCreator>>();
            foreach (PlLineType lineType in lineTypes)
            {
                switch (lineType)
                {
                    case PlLineType.Pl1:
                        tuples.Add(new Tuple<PlLineType, IPlLineCreator>(lineType, c1));
                        break;
                    case PlLineType.Pl2:
                        // ignore
                        break;
                    case PlLineType.Pl3:
                        tuples.Add(new Tuple<PlLineType, IPlLineCreator>(lineType, c3));
                        break;
                    case PlLineType.Pl4:
                        tuples.Add(new Tuple<PlLineType, IPlLineCreator>(lineType, c4));
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }

            if (!lineTypes.Contains(PlLineType.Pl3) && sensorLocation.SourceTypePl3 == DataSourceTypeSensors.LocationData)
            {
                tuples.Add(new Tuple<PlLineType, IPlLineCreator>(PlLineType.Pl3, c3));
            }

            if (!lineTypes.Contains(PlLineType.Pl4) && sensorLocation.SourceTypePl4 == DataSourceTypeSensors.LocationData)
            {
                tuples.Add(new Tuple<PlLineType, IPlLineCreator>(PlLineType.Pl4, c4));
            }

            return new SensorPlLineCreator(tuples);
        }

        /// <summary>
        /// Creates all PL lines.
        /// </summary>
        /// <returns>A PlLines set</returns>
        public PlLines CreateAllPlLines()
        {
            var lines = new PlLines();
            foreach (KeyValuePair<PlLineType, IPlLineCreator> item in creators)
            {
                IPlLineCreator creator = item.Value;
                PlLine PlLine = creator.CreatePlLine();
                lines.Lines[PlLine.PlLineType] = PlLine;
            }

            return lines;
        }

        /// <summary>
        /// Creates a PL line of the given type.
        /// </summary>
        /// <param name="type">The type of the PL line.</param>
        /// <returns>A PlLine instance</returns>
        public PlLine CreatePlLine(PlLineType type)
        {
            if (!creators.ContainsKey(type) || creators[type] == null)
            {
                throw new NotSupportedException("Creation of type " + type + " currently not supported");
            }

            return creators[type].CreatePlLine();
        }
    }
}