using SewerStammGen.Shared.Contracts;
using SewerStammGen.Shared.Domain;
using SewerStammGen.Shared.Enum;
using StammGenerator.Commands;
using StammGenerator.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Input;

namespace StammGenerator.ViewModel
{
    internal class HaltungEditViewModel : BaseViewModel
    {
        private readonly IActualState _actualState;
        private readonly IHaltungDataService _haltungDataService;
        private readonly ISchachtDataService _schachtDataService;
        private List<Schacht> avaibleSchaechte = new List<Schacht>();
        private int _selectedObenIndex;
        private int _selectedUntenIndex;
        private Kanal _model;

        public List<Schacht> AvSchaechte
        {
            get
            {
                return avaibleSchaechte;
            }
        }

        public EEntwaeserung Entwaeserung
        {
            get => _model.Entwaesserung;
            set
            {
                if(_model.Entwaesserung  != value)
                {
                    _model.Entwaesserung = value;
                    OnPropertyChanged();
                }
            }
        }
        

        public int SelectedObenIndex
        {
            get => _selectedObenIndex;
            set
            {
                if (_selectedObenIndex != value)
                {
                    _selectedObenIndex = value;
                    _model.StartSchacht = avaibleSchaechte[value];
                    RecalculateLength();
                    Haltungsbezeichnung = _model.StartSchacht.Objektbezeichnung;
                    OnPropertyChanged();
                }
            }
        }
        public int SelectedUntenIndex
        {
            get => _selectedUntenIndex;
            set
            {
                if (_selectedUntenIndex != value)
                {
                    _selectedUntenIndex = value;
                    _model.EndSchacht = avaibleSchaechte[value];
                    RecalculateLength();
                    OnPropertyChanged();
                }
            }
        }

        

        public Kanal Model
        {
            get => _model;
            set
            {
                _model = value;
            }
        }

        
        public string Haltungsbezeichnung
        {
            get => _model.Objektbezeichnung;
            set
            {
                if (_model.Objektbezeichnung != value)
                {
                    _model.Objektbezeichnung = value;
                    OnPropertyChanged();
                }
            }
        }
        public string Material
        {
            get => _model.Material;
            set
            {
                if (_model.Material != value)
                {
                    _model.Material = value;
                    OnPropertyChanged();
                }
            }
        }
        public string Durchmesser
        {
            get => _model.DN.ToString();
            set
            {
                if (_model.DN.ToString() != value)
                {
                    _model.DN = int.Parse(value);
                    OnPropertyChanged();
                }
            }
        }
        public string Haltungslaenge
        {
            get => _model.Haltungslaenge.ToString();
            set
            {
                if (_model.Haltungslaenge.ToString() != value)
                {
                    _model.Haltungslaenge = decimal.Parse(value);
                    OnPropertyChanged();
                }
            }
        }

        public ICommand Speichern { get; set; }
        public ICommand Abbrechen { get; set; }

        public HaltungEditViewModel(
            IHaltungDataService haltungDataService,
            IActualState actualState,
            IRenavigator renavigator,
            ISchachtDataService schachtDataService)
        {
            _actualState = actualState;
            _haltungDataService = haltungDataService;
            _schachtDataService = schachtDataService;



            _model = _actualState.SelectedHaltung;
            
            Speichern = new HaltungEditSaveCommand(_haltungDataService, renavigator, this);
            Abbrechen = new RelayCommand((x) => Abbruch(renavigator));

            ladeVerfuegbareSchaechte();



        }

        private void RecalculateLength()
        {

            double x1 = (double)Model.StartSchacht.DeckelRechtsWert;
            double x2 = (double)Model.EndSchacht.DeckelRechtsWert;
            double y1 = (double)Model.StartSchacht.DeckelHochWert;
            double y2 = (double)Model.EndSchacht.DeckelHochWert;


            double length = Math.Sqrt(((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2)));
            Haltungslaenge = string.Format("{0:0.00}", length);
            OnPropertyChanged(nameof(Haltungslaenge));
        }

        private void Abbruch(IRenavigator renavigator)
        {
            renavigator.Renavigate();
        }

        private async void ladeVerfuegbareSchaechte()
        {
            var s = await _schachtDataService.GetAllByProjekt(_actualState.ProjektID);
            avaibleSchaechte = s.ToList();
            int counter = 0;
            foreach (var d in avaibleSchaechte)
            {
                if (d.Id == Model.StartSchacht.Id)
                {
                    SelectedObenIndex = counter;
                    break;
                }
                counter++;
            }
            counter = 0;
            foreach (var d in avaibleSchaechte)
            {
                if (d.Id == Model.EndSchacht.Id)
                {
                    SelectedUntenIndex = counter;
                    break;
                }
                counter++;
            }
            OnPropertyChanged(nameof(AvSchaechte));
            OnPropertyChanged(nameof(SelectedObenIndex));
            OnPropertyChanged(nameof(SelectedUntenIndex));
        }
    }
}
