using MediaShare.Resources;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Net;
using MediaShare.Interface;
using System.Text.RegularExpressions;
using MediaShare.Constants;

namespace MediaShare.View
{
    public partial class AddDevicePage : ContentPage, INotifyPropertyChanged
    {
        private DeviceTabButtons _parent;
        private ObservableCollection<MediaShare.Model.DeviceInfo> _addedDeviceInfos;

        public event EventHandler<(string, string, string)> DeviceAdded;
        private bool _isAddButtonEnabled;
        public bool IsAddButtonEnabled
        {
            get { return _isAddButtonEnabled; }
            set
            {
                if (_isAddButtonEnabled != value)
                {
                    _isAddButtonEnabled = value;
                    OnPropertyChanged(nameof(IsAddButtonEnabled));
                    UpdateAddButtonBackgroundColor();
                }
            }
        }
        public event PropertyChangedEventHandler PropertyChanged;
        public AddDevicePage()
        {
            InitializeComponent();
        }
        public AddDevicePage(DeviceTabButtons parent, ObservableCollection<MediaShare.Model.DeviceInfo> addedDeviceInfos)
        {
            InitializeComponent();
            _parent = parent;
            _addedDeviceInfos = addedDeviceInfos ?? new ObservableCollection<MediaShare.Model.DeviceInfo>();
            IsAddButtonEnabled = false;
            PortEntry.Text = GlobalConstants.DEFAULT_PORT.ToString();
            NameEntry.TextChanged += OnNameEntryTextChanged;
            HostEntry.TextChanged += OnHostEntryTextChanged;
            PortEntry.TextChanged += OnPortEntryTextChanged;
            
            UpdateAddButtonBackgroundColor();
        }

        private async void OnAddClicked(object sender, EventArgs e)
        {
            if (string.IsNullOrWhiteSpace(NameEntry.Text))
            {
                string message = String_en.ProvideName;
                await DisplayAlert(String_en.Error_title, message, String_en.Ok_button);
                return;
            }

            if (NameEntry.Text.Length < 3)
            {
                string message = String_en.InvalidName;
                await DisplayAlert(String_en.Error_title, message, String_en.Ok_button);
                return;
            }

            string newDeviceName = NameEntry.Text.ToLowerInvariant();

            if (_addedDeviceInfos != null && _addedDeviceInfos.Any(device => device.DeviceName.ToLowerInvariant() == newDeviceName))
            {
                string message = string.Format(String_en.NameAlreadyExists, NameEntry.Text);
                await DisplayAlert(String_en.Error_title, string.Format(String_en.NameAlreadyExists, NameEntry.Text), String_en.Ok_button);
                return;
            }

            if (string.IsNullOrWhiteSpace(HostEntry.Text))
            {
                string message = String_en.ProvideHost;
                await DisplayAlert(String_en.Error_title, message, String_en.Ok_button);
                return;
            }
            if (!Regex.IsMatch(HostEntry.Text, @"^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$"))
            {
                string message = String_en.InvalidIP;
                await DisplayAlert(String_en.Error_title, String_en.InvalidIP, String_en.Ok_button);
                return;
            }
            if (_addedDeviceInfos != null && _addedDeviceInfos.Any(device => device.HostAddress == HostEntry.Text))
            {
                string message = string.Format(String_en.HostAlreadyExists, HostEntry.Text);
                await DisplayAlert(String_en.Error_title, message, String_en.Ok_button);
                return;
            }

            if (string.IsNullOrWhiteSpace(PortEntry.Text))
            {
                string message = String_en.InvalidPort;
                await DisplayAlert(String_en.Error_title, message, String_en.Ok_button);
                return;
            }
            var newDevice = new MediaShare.Model.DeviceInfo
            {
                DeviceName = NameEntry.Text,
                HostAddress = HostEntry.Text,
                Port = PortEntry.Text,
                DeviceInfoCombined = $"{NameEntry.Text}\n{HostEntry.Text}:{PortEntry.Text}"
            };

            DeviceAdded?.Invoke(this, (NameEntry.Text, HostEntry.Text, PortEntry.Text));
            _parent?.ExecuteRefreshCommand();
            string successMessage = string.Format(String_en.DeviceAdded, NameEntry.Text);
            await DisplayAlert(String_en.Success_title, successMessage, String_en.Ok_button);
            await Navigation.PopAsync();
        }

        private void UpdateAddButtonBackgroundColor()
        {
            if (IsAddButtonEnabled)
            {
                AddButton.BackgroundColor = Color.FromArgb("#017ccc");
                AddButton.TextColor = Colors.White;
            }
            else
            {
                AddButton.BackgroundColor = Color.FromArgb("#cde2f3");
                AddButton.TextColor = Color.FromArgb("#017ccc");
                AddButton.BorderColor = Color.FromArgb("#017ccc");
            }
        }

        private async void OnCancelClicked(object sender, EventArgs e)
        {
            await Navigation.PopAsync();
        }

        private void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        private void UpdateAddButtonState()
        {
            IsAddButtonEnabled = !string.IsNullOrWhiteSpace(NameEntry.Text) &&
                                 NameEntry.Text.Length >= 3 &&
                                 !string.IsNullOrWhiteSpace(HostEntry.Text) &&
                                 !string.IsNullOrWhiteSpace(PortEntry.Text);

            UpdateAddButtonBackgroundColor();
        }

        void OnNameEntryTextChanged(object sender, TextChangedEventArgs e)
        {
            if (string.IsNullOrWhiteSpace(e.NewTextValue))
            {
                InvalidNameLabel.IsVisible = true;
                NameErrorLabel.IsVisible = false;
            }
            else
            {
                InvalidNameLabel.IsVisible = false;
                NameErrorLabel.IsVisible = e.NewTextValue.Length < 3;
            }
            UpdateAddButtonState();
        }

        void OnNameEntryFocused(object sender, FocusEventArgs e)
        {
            NameLabel.IsVisible = true;
        }

        void OnNameEntryUnfocused(object sender, FocusEventArgs e)
        {
            NameLabel.IsVisible = !string.IsNullOrEmpty(NameEntry.Text);
        }

        void OnHostEntryFocused(object sender, FocusEventArgs e)
        {
            HostLabel.IsVisible = true;
        }

        void OnHostEntryUnfocused(object sender, FocusEventArgs e)
        {
            var hostEntry = sender as Entry;
            if (string.IsNullOrWhiteSpace(hostEntry.Text))
            {
                InvalidHostLabel.IsVisible = true;
                HostErrorLabel.IsVisible = false;
            }
            else
            {
                InvalidHostLabel.IsVisible = false;
                HostErrorLabel.IsVisible = !Regex.IsMatch(hostEntry.Text, @"^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$");
            }
            UpdateAddButtonState();
        }

        void OnPortEntryTextChanged(object sender, TextChangedEventArgs e)
        {
            if (string.IsNullOrWhiteSpace(e.NewTextValue))
            {
                InvalidPortLabel.IsVisible = true;
            }
        }

        void OnPortEntryFocused(object sender, FocusEventArgs e)
        {
            PortLabel.IsVisible = true;
        }

        void OnPortEntryUnfocused(object sender, FocusEventArgs e)
        {
            var portEntry = sender as Entry;
            if (string.IsNullOrWhiteSpace(portEntry.Text))
            {
                InvalidPortLabel.IsVisible = true;
            }
            else
            {
                InvalidPortLabel.IsVisible = false;
            }
            UpdateAddButtonState();
        }

        private void OnHostEntryTextChanged(object sender, TextChangedEventArgs e)
        {
            if (string.IsNullOrWhiteSpace(e.NewTextValue))
            {
                InvalidHostLabel.IsVisible = true;
                HostErrorLabel.IsVisible = false;
            }
            else
            {
                InvalidHostLabel.IsVisible = false;
            }
            UpdateAddButtonState();
        }
    }
}