//-----------------------------------------------------------------------
// <copyright file="WaterBoard.cs" company="Deltares">     
//  Copyright (c) 2011 Deltares. All rights reserved.
// </copyright>
// <author>J. Bokma</author>
// <email>j.bokma@deltares.nl</email>
// <date>02-02-2011</date>
// <summary>n.a.</summary>
//-----------------------------------------------------------------------
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;

namespace Deltares.Dam.Data
{
    public class WaterBoard : IVisibleEnabled, IDisposable
    {
        private string description = "";
        private IList<Dike> dikes;
        private List<Location> locations = null;
        private readonly FeatureRepository backgroundRepository;
        private IList<BackgroundRepositoryFeature> featureList = null;
        private IList<Segment> segments;
        private IList<SoilGeometry2DName> soilgeometry2DNames;
        private string waterLevelTimeSeriesFileName;
        private IVisibleEnabledProvider visibleEnabledProvider;
        private Dike selectedDike;

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

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

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

        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))
                    {
                        SoilGeometry2DName soilGeometry2DName = new SoilGeometry2DName();
                        soilGeometry2DName.Geometry2DName = soilGeometryProbability.SoilGeometry2DName;
                        SoilGeometry2DNames.Add(soilGeometry2DName);
                    }
                }
            }
        }

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

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

        /// <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);
            }
        }

        private bool SoilGeometry2DNamesContains(string Name)
        {
            foreach (var 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)); 
                }                                        
            }

        }

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

        public virtual IList<Dike> Dikes
        {
            get { return this.dikes; }
            set { this.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 this.Dikes)
                    {
                        locations.AddRange(dike.Locations);
                    }
                }

                return locations;
            }
        }

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

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

        public virtual string Description
        {
            get { return description; }
            set { description = value; }
        }

        public override string ToString()
        {
            return Name;
        }

        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;
            }
        }

        [XmlIgnore]
        [Browsable(false)]
        public IVisibleEnabledProvider VisibleEnabledProvider
        {
            get { return visibleEnabledProvider; }
            set { visibleEnabledProvider = value; }
        }

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

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

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

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

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