using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using Tango.BL.Entities;
using Tango.Core.DI;
using Tango.Core.Helpers;
using Tango.Integration.Operation;
using Tango.Logging;
using Tango.MachineStudio.Common.Authentication;
using Tango.MachineStudio.Common.StudioApplication;
using Tango.SharedUI.Helpers;
using Tango.TFS;

namespace Tango.MachineStudio.UI.TFS
{
    public class TeamFoundationServiceExtendedClient : TeamFoundationServiceClient
    {
        public Project Project { get; private set; }

        private ObservableCollection<WorkItem> _resolvedWorkItems;
        public ObservableCollection<WorkItem> ResolvedWorkItems
        {
            get { return _resolvedWorkItems; }
            set { _resolvedWorkItems = value; RaisePropertyChangedAuto(); }
        }

        private bool _isInitialized;
        public bool IsInitialized
        {
            get { return _isInitialized; }
            private set { _isInitialized = value; RaisePropertyChangedAuto(); }
        }

        public TeamFoundationServiceExtendedClient(string collectionURL, string userName, string personalToken) : base(collectionURL, userName, personalToken)
        {
            ResolvedWorkItems = new ObservableCollection<WorkItem>();
            TangoIOC.Default.GetInstance<IAuthenticationProvider>().CurrentUserChanged += TeamFoundationServiceExtendedClient_CurrentUserChanged;
        }

        private void TeamFoundationServiceExtendedClient_CurrentUserChanged(object sender, User user)
        {
            if (user != null)
            {
                Task.Factory.StartNew(async () =>
                {
                    Thread.Sleep(5000);
                    await UpdateCurrentUserResolvedWorkItems();
                });
            }
        }

        public Task<WorkItem> UploadWorkItem(WorkItem workItem)
        {
            return UploadWorkItem(Project, workItem);
        }

        public async Task UpdateCurrentUserResolvedWorkItems()
        {
            try
            {
                IStudioApplicationManager app = TangoIOC.Default.GetInstance<IStudioApplicationManager>();
                var items = await GetWorkItemsCreatedBy(Project, GetUserTeamMember());
                items.Where(x => x.StepsToReproduce != null).ToList().ForEach(x => x.StepsToReproduce = x.StepsToReproduce.Replace("<div style=\"white-space:pre;\">", "").Replace("</div>", ""));
                ResolvedWorkItems = items.Where(x => x.State == State.Resolved && x.ResolvedReason == ResolvedReason.Fixed && x.IsBuildVersionValid && x.FoundInBuildVersion < Version.Parse(app.Version)).ToObservableCollection();
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error getting the current user resolved work items.");
            }
        }

        public async Task<WorkItem> CloseWorkItem(WorkItem workItem)
        {
            await SetWorkItemState(Project, workItem, State.Closed);
            var updated = await AddWorkItemComment(Project, workItem, GetUserTeamMember(), "Bug has been verified and closed by " + GetUserTeamMember().DisplayName + " (via Tango Software).");
            ResolvedWorkItems.Remove(workItem);
            return updated;
        }

        public async Task<WorkItem> ReactivateWorkItem(WorkItem workItem)
        {
            await SetWorkItemState(Project, workItem, State.New);
            var updated = await AddWorkItemComment(Project, workItem, GetUserTeamMember(), "Bug has been reactivated by " + GetUserTeamMember().DisplayName + " (via Tango Software).");
            updated = await SetWorkItemAssignment(Project, updated, workItem.ResolvedBy);
            ResolvedWorkItems.Remove(workItem);
            return updated;
        }

        public void Initialize()
        {
            Task.Factory.StartNew(() =>
            {
                if (!IsInitialized)
                {
                    try
                    {
                        Project = GetProject("Tango").Result;
                        IsInitialized = true;
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log(ex, "Error initializing the Team Foundation Service client.");
                    }
                }
            });
        }

        public WorkItem CreateBug()
        {
            WorkItem item = new WorkItem();

            IAuthenticationProvider auth = TangoIOC.Default.GetInstance<IAuthenticationProvider>();
            IStudioApplicationManager app = TangoIOC.Default.GetInstance<IStudioApplicationManager>();

            item.Area = Project.Areas.FirstOrDefault();
            item.Iteration = Project.Iterations.FirstOrDefault();

            TeamMember currentUser = GetUserTeamMember();
            item.CreatedBy = currentUser;
            item.ChangedBy = currentUser;
            item.AuthorizedAs = currentUser;

            item.FoundInBuild = app.Version;
            item.Priority = Priority.Priority3;
            item.Severity = Severity.Medium;
            item.State = State.New;
            item.Type = WorkItemType.Bug;

            var bitmap = UIHelper.TakeSnapshot(MainWindow.Instance);
            var tempFile = TemporaryManager.CreateFile();
            bitmap.SaveJpeg(tempFile.Path, 30);

            item.Attachments.Add(new Attachment()
            {
                Description = "Screen Capture",
                FilePath = tempFile.Path,
                Name = "Screen Capture.jpg",
            });

            return item;
        }

        public void FinalizeBug(WorkItem item)
        {
            IAuthenticationProvider auth = TangoIOC.Default.GetInstance<IAuthenticationProvider>();
            IStudioApplicationManager app = TangoIOC.Default.GetInstance<IStudioApplicationManager>();

            FileLogger appFileLogger = LogManager.Default.RegisteredLoggers.FirstOrDefault(x => x.GetType() == typeof(FileLogger)) as FileLogger;
            FileLogger embeddedFileLogger = MachineOperator.EmbeddedLogManager.RegisteredLoggers.FirstOrDefault(x => x.GetType() == typeof(FileLogger)) as FileLogger;

            if (appFileLogger != null)
            {
                var appLogFile = TemporaryManager.CreateFile();
                File.Copy(appFileLogger.LogFile, appLogFile.Path);

                item.Attachments.Add(new Attachment()
                {
                    Description = "Application Log File",
                    FilePath = appLogFile.Path,
                    Name = Path.GetFileName(appFileLogger.LogFile),
                });
            }

            if (embeddedFileLogger != null && File.Exists(embeddedFileLogger.LogFile))
            {
                var embeddedLogFile = TemporaryManager.CreateFile();
                File.Copy(appFileLogger.LogFile, embeddedLogFile.Path);

                item.Attachments.Add(new Attachment()
                {
                    Description = "Embedded Log File",
                    FilePath = embeddedLogFile.Path,
                    Name = Path.GetFileName(embeddedFileLogger.LogFile),
                });
            }

            SystemInformationModel sysModel = new SystemInformationModel();
            sysModel.ApplicationVersion = app.Version;
            sysModel.EmbeddedVersion = "N/A";
            sysModel.HostName = Environment.MachineName;
            sysModel.UserName = auth.CurrentUser.Contact.FullName;

            if (app.ConnectedMachine != null)
            {
                Machine machine = app.ConnectedMachine.Machine;

                sysModel.Machine = machine;
                sysModel.EmbeddedVersion = app.ConnectedMachine.DeviceInformation.Version;

                MachineDesigner.Views.MainView machineView = new MachineDesigner.Views.MainView();
                machineView.Width = 1280;
                machineView.Height = 1100;
                machineView.PanelColumnDefinition.Width = new GridLength(0);
                machineView.stackHeader.Visibility = Visibility.Collapsed;
                machineView.Background = System.Windows.Media.Brushes.White;
                machineView.DataContext = new MachineDesigner.ViewModels.MainViewVM() { SelectedMachine = machine, Configuration = machine.Configuration };

                var configImageFile = TemporaryManager.CreateFile();
                machineView.RenderToFile(configImageFile.Path, System.Drawing.Imaging.ImageFormat.Jpeg, new Size(machineView.Width, machineView.Height), 100);

                item.Attachments.Add(new Attachment()
                {
                    Description = "Machine Configuration",
                    FilePath = configImageFile.Path,
                    Name = "Machine Configuration.jpg"
                });

                sysModel.ConfigurationString = machine.Configuration.CloneConfiguration().ToJsonString(nameof(Configuration.MachinesConfigurations), nameof(Configuration.MachineVersions));

                if (app.ConnectedMachine.CurrentProcessParameters != null)
                {
                    sysModel.LoadedProcessParametersString = app.ConnectedMachine.CurrentProcessParameters.ToJsonString(nameof(ProcessParametersTable.ProcessParametersTablesGroup));
                }

                if (app.ConnectedMachine.CurrentHardwareConfiguration != null)
                {
                    sysModel.LoadedHardwareConfigurationString = app.ConnectedMachine.CurrentHardwareConfiguration.ToJsonString();
                }
            }

            String html = String.Empty;

            using (var stream = EmbeddedResourceHelper.GetEmbeddedResourceStream("Tango.MachineStudio.UI.TFS.SystemInformationTemplate.cshtml"))
            {
                StreamReader reader = new StreamReader(stream);
                html = reader.ReadToEnd();
            }

            item.SystemInformation = CodeGeneration.Helper.Parse(html, sysModel);

            item.StepsToReproduce = String.Format("<div style=\"white-space:pre\">{0}</div>", item.StepsToReproduce);
        }

        private TeamMember GetUserTeamMember()
        {
            IAuthenticationProvider auth = TangoIOC.Default.GetInstance<IAuthenticationProvider>();
            TeamMember currentUser = Project.Members.SingleOrDefault(x => x.UniqueName.ToLower().Contains(auth.CurrentUser.Email.ToLower()));
            return currentUser;
        }
    }
}