//-----------------------------------------------------------------------
// <copyright file="PipingDAMInput.cs" company="Deltares">
//  Copyright (c) 2010 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T. The</author>
// <email>tom.the@deltares.nl</email>
// <date>8-9-2010</date>
// <summary></summary>
//-----------------------------------------------------------------------
namespace Deltares.Piping.Data
{
    using System.Collections.Generic;

    public class PipingDAMInput
    {
        private const double cQ1 = 16000.0;
        private const double cQ2 = 15000.0;
        private const double cQ3 = 10000.0;
        private const double cQ4 = 4000.0;
        private const double cQ5 = 2000.0;

        public List<PipingDAMRegionInfo> fRegionInfos = new List<PipingDAMRegionInfo>();
        private PipingCommonData fCommonData = new PipingCommonData();
        private List<PipingDAMLocationGeometryStruct> fLocationGeometries = new List<PipingDAMLocationGeometryStruct>();
        private List<PipingDAMLocationSoilStruct> fLocationSoils = new List<PipingDAMLocationSoilStruct>();
        private List<PipingDAMSegmentSoilRelationStruct> fLocationSegmentSoilRelations = new List<PipingDAMSegmentSoilRelationStruct>();
        private List<PipingDAMWaterLevelInfoStruct> fPipingDAMWaterLevels = new List<PipingDAMWaterLevelInfoStruct>();

        public List<PipingDAMRegionInfo> RegionInfos
        {
            get { return fRegionInfos; }
        }
        public PipingCommonData CommonData
        {
            get { return fCommonData; }
        }

        public List<PipingDAMLocationGeometryStruct> LocationGeometries
        {
            get { return fLocationGeometries; }
        }

        public List<PipingDAMLocationSoilStruct> LocationSoils
        {
            get { return fLocationSoils; }
        }

        public List<PipingDAMSegmentSoilRelationStruct> LocationSegmentSoilRelations
        {
            get { return fLocationSegmentSoilRelations; }
        }

        public List<PipingDAMWaterLevelInfoStruct> PipingDAMWaterLevels
        {
            get { return fPipingDAMWaterLevels; }
        }

        /// <summary>
        /// Find geometry that belongs to the given location name
        /// </summary>
        /// <param name="aLocationName"></param>
        /// <returns></returns>
        public PipingDAMLocationGeometryStruct GetLocationGeometry(string aLocationName)
        {
            PipingDAMLocationGeometryStruct selectedLocationGeometry = new PipingDAMLocationGeometryStruct("", "", 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
            foreach (PipingDAMLocationGeometryStruct locationGeometry in fLocationGeometries)
            {
                if (locationGeometry.Name == aLocationName)
                {
                    selectedLocationGeometry = locationGeometry;
                    break;
                }
            }
            return selectedLocationGeometry;
        }

        /// <summary>
        /// Find soil for given soilname
        /// </summary>
        /// <param name="aName"></param>
        /// <returns></returns>
        public PipingDAMLocationSoilStruct GetSoil(string aName)
        {
            PipingDAMLocationSoilStruct selectedSoil = new PipingDAMLocationSoilStruct("", 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
            foreach (PipingDAMLocationSoilStruct soil in fLocationSoils)
            {
                if (soil.Name == aName)
                {
                    selectedSoil = soil;
                    break;
                }
            }
            return selectedSoil;
        }

        /// <summary>
        /// Find soil list belonging to given location name
        /// </summary>
        /// <param name="aLocationName"></param>
        /// <returns></returns>
        public List<PipingDAMLocationSoilStruct> GetLocationSoils(string aLocationName)
        {
            List<PipingDAMLocationSoilStruct> locationSoils = new List<PipingDAMLocationSoilStruct>();
            PipingDAMLocationGeometryStruct selectedLocationGeometry = GetLocationGeometry(aLocationName);
            if (selectedLocationGeometry.Name != "")
            {
                foreach (PipingDAMSegmentSoilRelationStruct segmentSoilRelation in LocationSegmentSoilRelations)
                {
                    if (segmentSoilRelation.SegmentName == selectedLocationGeometry.SegmentName)
                    {
                        PipingDAMLocationSoilStruct soil = GetSoil(segmentSoilRelation.SoilName);
                        if (soil.Name != "")
                        {
                            soil.ChanceOccurence = segmentSoilRelation.ChanceOccurence;
                            locationSoils.Add(soil);
                        }
                    }
                }
            }
            return locationSoils;
        }

        /// <summary>
        /// Find waterlevel info belonging to given location name
        /// </summary>
        /// <param name="aLocationName"></param>
        /// <returns></returns>
        public PipingDAMWaterLevelInfoStruct GetLocationWaterLevelInfo(string aLocationName)
        {
            PipingDAMWaterLevelInfoStruct selectedWaterLevel = new PipingDAMWaterLevelInfoStruct("", 0.0, 0.0, 0.0, 0.0, 0.0);
            foreach (PipingDAMWaterLevelInfoStruct waterLevel in fPipingDAMWaterLevels)
            {
                if (waterLevel.LocationName == aLocationName)
                {
                    selectedWaterLevel = waterLevel;
                    break;
                }
            }
            return selectedWaterLevel;
        }

        /// <summary>
        /// Determine waterlevel at certain location given the waterflow in Lobith
        /// </summary>
        /// <param name="aLocationName"></param>
        /// <param name="aFlowLobith"></param>
        public double DetermineWaterLevel(string aLocationName, double aFlowLobith)
        {
            double waterLevel = 0.0;
            PipingDAMWaterLevelInfoStruct waterLevelInfo = GetLocationWaterLevelInfo(aLocationName);
            if (waterLevelInfo.LocationName == aLocationName)
            {
                waterLevel = WaterLevelInterpolation(waterLevelInfo, aFlowLobith);
            }
            return waterLevel;
        }

        public double WaterLevelInterpolation(PipingDAMWaterLevelInfoStruct aWaterLevelInfo, double aFlow)
        {
            List<PipingDAMQHPoint> waterLevelPoints = new List<PipingDAMQHPoint>();
            waterLevelPoints.Add(new PipingDAMQHPoint(cQ1, aWaterLevelInfo.H1));
            waterLevelPoints.Add(new PipingDAMQHPoint(cQ2, aWaterLevelInfo.H2));
            waterLevelPoints.Add(new PipingDAMQHPoint(cQ3, aWaterLevelInfo.H3));
            waterLevelPoints.Add(new PipingDAMQHPoint(cQ4, aWaterLevelInfo.H4));
            waterLevelPoints.Add(new PipingDAMQHPoint(cQ5, aWaterLevelInfo.H5));
            if (aFlow >= waterLevelPoints[0].Q)
            {
                return waterLevelPoints[0].H;
            }
            if (aFlow <= waterLevelPoints[waterLevelPoints.Count - 1].Q)
            {
                return waterLevelPoints[waterLevelPoints.Count - 1].H;
            }
            PipingDAMQHPoint firstPoint = waterLevelPoints[0];
            PipingDAMQHPoint secondPoint = waterLevelPoints[0];
            for (int indexPoint = 1; indexPoint < waterLevelPoints.Count; indexPoint++)
            {
                firstPoint = waterLevelPoints[indexPoint - 1];
                secondPoint = waterLevelPoints[indexPoint];
                if (aFlow >= secondPoint.Q)
                {
                    break;
                }
            }
            double factorQ = (firstPoint.Q - aFlow) / (firstPoint.Q - secondPoint.Q);
            double waterLevel = firstPoint.H - factorQ * (firstPoint.H - secondPoint.H);

            return waterLevel;
        }
    }
}