using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core.Commands;
using Tango.PPC.BugReporting.TFS;
using Tango.PPC.Common;
using Tango.Settings;
using Tango.TFS;
using Tango.Touch.Controls;

namespace Tango.PPC.BugReporting.ViewModels
{
    /// <summary>
    /// Represents the main view VM and entry point for <see cref="Synchronization.MyModule"/>.
    /// </summary>
    /// <seealso cref="Tango.PPC.Common.PPCViewModel" />
    public class MainViewVM : PPCViewModel
    {
        private TeamFoundationServicePPCClient _tfsService;
        private BugReportingSettings _settings;

        public AutoCompleteProvider<TeamMember> TeamMembersProvider { get; set; }

        private String _title;
        public String Title
        {
            get { return _title; }
            set { _title = value; RaisePropertyChangedAuto(); }
        }

        private String _steps;
        public String Steps
        {
            get { return _steps; }
            set { _steps = value; RaisePropertyChangedAuto(); }
        }

        private TeamMember _fromMember;
        public TeamMember FromMember
        {
            get { return _fromMember; }
            set { _fromMember = value; RaisePropertyChangedAuto(); }
        }

        private TeamMember _toMember;
        public TeamMember ToMember
        {
            get { return _toMember; }
            set { _toMember = value; RaisePropertyChangedAuto(); }
        }

        private Severity _severity;
        public Severity Severity
        {
            get { return _severity; }
            set { _severity = value; RaisePropertyChangedAuto(); }
        }

        private List<TeamMember> _members;
        public List<TeamMember> Members
        {
            get { return _members; }
            set { _members = value; RaisePropertyChangedAuto(); }
        }

        public RelayCommand SubmitCommand { get; set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="MainViewVM"/> class.
        /// </summary>
        public MainViewVM()
        {
            TeamMembersProvider = new AutoCompleteProvider<TeamMember>((member, filter) =>
            {
                if (filter != null && member != null)
                {
                    return member.DisplayName.ToLower().Contains(filter.ToLower());
                }
                else
                {
                    return false;
                }
            });

            Severity = Severity.Medium;

            SubmitCommand = new RelayCommand(SubmitBug);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MainViewVM"/> class.
        /// </summary>
        /// <param name="tfsService">The TFS service.</param>
        public MainViewVM(TeamFoundationServicePPCClient tfsService) : this()
        {
            _tfsService = tfsService;
            _tfsService.Initialized += _tfsService_Initialized;
        }

        private void _tfsService_Initialized(object sender, EventArgs e)
        {
            Members = _tfsService.Project.Members.ToList();
        }

        private async void SubmitBug()
        {
            if (String.IsNullOrWhiteSpace(Title))
            {
                await NotificationProvider.ShowError("Report title is required.");
                return;
            }

            if (FromMember == null)
            {
                await NotificationProvider.ShowError("Created By team member is required.");
                return;
            }

            if (ToMember == null)
            {
                await NotificationProvider.ShowError("Assigned To team member is required.");
                return;
            }

            try
            {
                IsFree = false;
                await _tfsService.SubmitBug(Title, Steps, FromMember, ToMember, Severity);
                await NotificationProvider.ShowSuccess("Issue reported successfully");
                await NavigationManager.NavigateBack();

                _settings.LastCreatedBy = FromMember.Email;
                _settings.LastAssignedTo = ToMember.Email;
                _settings.Save();

                Title = null;
                Steps = null;
                Severity = Severity.Medium;
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error on TFS bug reporting.");
                await NotificationProvider.ShowError("An error occurred while trying to submit the report. Please restart the application and try again.");
            }
            finally
            {
                IsFree = true;
            }
        }

        public async override void OnNavigatedTo()
        {
            base.OnNavigatedTo();

            Title = null;
            Steps = null;
            Severity = Severity.Medium;

            if (!_tfsService.IsInitialized)
            {
                await NotificationProvider.ShowError("The reporting service was not initialized properly. Issue reporting is currently disabled.");
                await NavigationManager.NavigateBack();
                return;
            }

            FromMember = Members.SingleOrDefault(x => x.Email == _settings.LastCreatedBy);
            ToMember = Members.SingleOrDefault(x => x.Email == _settings.LastAssignedTo);
        }

        /// <summary>
        /// Called when the application has been started
        /// </summary>
        public override void OnApplicationStarted()
        {
            //Start initializing here rather then in the constructor.

            _settings = SettingsManager.Default.GetOrCreate<BugReportingSettings>();
        }
    }
}