using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel.DataAnnotations;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core.Commands;
using Tango.Core.DI;
using Tango.Core.Helpers;
using Tango.FSE.Common;
using Tango.FSE.Common.AutoComplete;
using Tango.FSE.Common.BugReporting;
using Tango.FSE.Common.Notifications;
using Tango.FSE.Common.Storage;
using Tango.TFS;

namespace Tango.FSE.UI.Dialogs
{
    public class BugReportFullViewVM : BugReportViewVM
    {
        [TangoInject]
        private INotificationProvider NotificationProvider { get; set; }

        [TangoInject]
        private IStorageProvider StorageProvider { get; set; }

        public List<Area> Areas { get; set; }

        private Area _area;
        [Required(ErrorMessage = "Area is required")]
        public Area Area
        {
            get { return _area; }
            set { _area = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        public List<TeamMember> TeamMembers { get; set; }

        public AutoCompleteSource<TeamMember> TeamMembersAutoComplete { get; set; }

        private TeamMember _assignedTo;
        [Required(ErrorMessage = "Assigned To is required")]
        public TeamMember AssignedTo
        {
            get { return _assignedTo; }
            set { _assignedTo = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        private String _stepsToReproduce;
        public String StepsToReproduce
        {
            get { return _stepsToReproduce; }
            set { _stepsToReproduce = value; RaisePropertyChangedAuto(); }
        }

        public ObservableCollection<BugAttachement> Attachments { get; set; }
        public ObservableCollection<BugAttachement> SelectedAttachements { get; set; }

        public RelayCommand AddAttachementCommand { get; set; }
        public RelayCommand RemoveSelectedAttachementsCommand { get; set; }

        public BugReportFullViewVM() : base()
        {
            Attachments = new ObservableCollection<BugAttachement>();
            SelectedAttachements = new ObservableCollection<BugAttachement>();
            SelectedAttachements.CollectionChanged += (_, __) => InvalidateRelayCommands();
            TeamMembersAutoComplete = new AutoCompleteSource<TeamMember>(FilterTeamMembers);
            AddAttachementCommand = new RelayCommand(AddAttachement);
            RemoveSelectedAttachementsCommand = new RelayCommand(RemoveSelectedAttachements, () => SelectedAttachements.Count > 0);
        }

        public BugReportFullViewVM(Bug bug) : this()
        {
            if (bug != null)
            {
                Bug = bug;
                Title = Bug.Title;
                Description = Bug.Description;
            }
        }

        private List<TeamMember> FilterTeamMembers(string filter)
        {
            if (TeamMembers != null)
            {
                return TeamMembers.Where(x => String.IsNullOrWhiteSpace(filter) || x.DisplayName.ToLower().Contains(filter.ToLower())).ToList();
            }

            return new List<TeamMember>();
        }

        private async void AddAttachement()
        {
            var result = await StorageProvider.OpenFiles("Select file/s to attach");

            if (result.Confirmed)
            {
                foreach (var file in result.SelectedItems)
                {
                    String fileName = Path.GetFileName(file);

                    if (new FileInfo(file).Length > 1000000 * 60) // 60MB limit
                    {
                        await NotificationProvider.ShowError($"The size of '{fileName}' exceeds the maximum 60 MB limit.");
                        continue;
                    }

                    Attachments.Add(new BugAttachement()
                    {
                        Name = fileName,
                        File = file,
                        Description = fileName
                    });
                }

                InvalidateRelayCommands();
            }
        }

        private void RemoveSelectedAttachements()
        {
            foreach (var attachement in SelectedAttachements.ToList())
            {
                Attachments.Remove(attachement);
            }

            SelectedAttachements.Clear();

            InvalidateRelayCommands();
        }

        protected override void Accept()
        {
            if (Validate())
            {
                Bug.Title = Title;
                Bug.Description = Description;
                Bug.Comments = Comments;
                Bug.StepsToReproduce = StepsToReproduce;
                Bug.AssignedTo = AssignedTo;
                Bug.Area = Area;
                Bug.Attachments = Attachments.ToList();

                base.Accept();
            }
        }
    }
}