// Copyright (C) Stichting Deltares 2025. All rights reserved.
// 
// This file is part of the application DAM - UI.
// 
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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 General Public License for more details.
// 
// You should have received a copy of the GNU 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.ComponentModel;
using System.Linq;
using System.Xml.Serialization;
using Deltares.Maps;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Language;
using Deltares.Standard.Validation;

namespace Deltares.Dam.Data;

public class WaterBoard : IVisibleEnabled, IDisposable
{
    private readonly FeatureRepository backgroundRepository;
    private IList<Dike> dikes;
    private List<Location> locations;
    private IList<BackgroundRepositoryFeature> featureList;
    private IList<Segment> segments;
    private IList<SoilGeometry2DName> soilgeometry2DNames;
    private string waterLevelTimeSeriesFileName;
    private Dike selectedDike;

    public WaterBoard()
    {
        dikes = new List<Dike>();
        featureList = new List<BackgroundRepositoryFeature>();
        backgroundRepository = new FeatureRepository();
        segments = new List<Segment>();
        soilgeometry2DNames = new List<SoilGeometry2DName>();
    }

    public virtual IList<Segment> Segments
    {
        get
        {
            return segments;
        }
        set
        {
            segments = value;
        }
    }

    public virtual IList<SoilGeometry2DName> SoilGeometry2DNames
    {
        get
        {
            return soilgeometry2DNames;
        }
        set
        {
            soilgeometry2DNames = value;
        }
    }

    /// <summary>
    /// Gets the selected dike.
    /// Is a helper property to be able to show the soil table. When more Dikes than one are allowed,
    /// this has to become a "real" property set by the onselectionchanged event.
    /// </summary>
    /// <value>
    /// The selected dike.
    /// </value>
    public Dike SelectedDike
    {
        get
        {
            if (selectedDike != null)
            {
                return selectedDike;
            }

            return dikes.Count > 0 ? dikes[0] : null;
        }
        set
        {
            DataEventPublisher.BeforeChange(this, x => x.SelectedDike);
            selectedDike = value;
            DataEventPublisher.AfterChange(this, x => x.SelectedDike);
        }
    }

    public virtual IList<BackgroundRepositoryFeature> BackgroundRepositoryFeatures
    {
        get
        {
            return featureList;
        }
        set
        {
            featureList = value;
            FillBackGroundRepos();
        }
    }

    [Validate]
    public virtual IList<Dike> Dikes
    {
        get
        {
            return dikes;
        }
        set
        {
            dikes = value;
        }
    }

    [XmlIgnore]
    [Browsable(false)]
    [ReadOnly(true)]
    [Label("Locations")]
    public List<Location> Locations
    {
        get
        {
            if (locations == null)
            {
                locations = new List<Location>();
                foreach (Dike dike in Dikes)
                {
                    locations.AddRange(dike.Locations);
                }
            }

            return locations;
        }
    }

    [Label("Number of Dikes")]
    public virtual string NumberOfDikes
    {
        get
        {
            return dikes.Count.ToString();
        }
    }

    public virtual string Name
    {
        get
        {
            return String.Format(LocalizationManager.GetTranslatedText(this, "WaterBoard"));
        }
    }

    public virtual string Description { get; set; } = "";

    [XmlIgnore] [Browsable(false)] public IVisibleEnabledProvider VisibleEnabledProvider { get; set; }

    [Label("Waterlevel timeseries filename")]
    public string WaterLevelTimeSeriesFileName
    {
        get
        {
            return waterLevelTimeSeriesFileName;
        }
        set
        {
            DataEventPublisher.BeforeChange(this, "WaterLevelTimeSeriesFileName");
            waterLevelTimeSeriesFileName = value;
            DataEventPublisher.AfterChange(this, "WaterLevelTimeSeriesFileName");
        }
    }

    public void FillGeometry2DNamesFromSegments()
    {
        // Add soilgeometry2D names into list
        foreach (Segment segment in Segments)
        {
            foreach (SoilGeometryProbability soilGeometryProbability in segment.SoilProfileProbabilities)
            {
                if (soilGeometryProbability.SoilGeometry2DName != null && !SoilGeometry2DNamesContains(soilGeometryProbability.SoilGeometry2DName))
                {
                    var soilGeometry2DName = new SoilGeometry2DName();
                    soilGeometry2DName.Geometry2DName = soilGeometryProbability.SoilGeometry2DName;
                    SoilGeometry2DNames.Add(soilGeometry2DName);
                }
            }
        }
    }

    public void FillFeatureList()
    {
        foreach (IFeature feature in backgroundRepository.Features)
        {
            var featureStr = new BackgroundRepositoryFeature();
            featureStr.Feature = feature.WktFormat;
            featureList.Add(featureStr);
        }
    }

    /// <summary>
    /// Updates the locations for scenarios.
    /// </summary>
    public void UpdateLocationsForScenarios()
    {
        foreach (Dike dike in Dikes)
        {
            dike.UpdateLocationsForScenarios();
        }
    }

    public void AddBackgroundGeometry(IFeature geometry)
    {
        backgroundRepository.Add(geometry);
    }

    public Segment GetSegmentByName(string segmentId)
    {
        Segment segment = segments.Where(x => ((x.Name == segmentId))).FirstOrDefault();
        return segment;
    }

    public override string ToString()
    {
        return Name;
    }

    public void Dispose()
    {
        foreach (Dike dike in Dikes)
        {
            dike.Dispose();
        }
    }

    public bool IsVisible(string property)
    {
        switch (property)
        {
            case "SelectedDike": return VisibleEnabledProvider != null && VisibleEnabledProvider.IsVisible(this, "SelectedDike");
            case "WaterLevelTimeSeriesFileName": return Location.DamProjectType == DamProjectType.Calamity;
            default: return true;
        }
    }

    public bool IsEnabled(string property)
    {
        return true;
    }

    private bool SoilGeometry2DNamesContains(string Name)
    {
        foreach (SoilGeometry2DName soilGeometry2DName in SoilGeometry2DNames)
        {
            if (soilGeometry2DName.Geometry2DName == Name)
            {
                return true;
            }
        }

        return false;
    }

    private void FillBackGroundRepos()
    {
        if (featureList != null)
        {
            backgroundRepository.Clear();
            foreach (BackgroundRepositoryFeature s in featureList)
            {
                backgroundRepository.Add(Feature.Create(s.Feature));
            }
        }
    }
}