using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IceBreaker.Model
{
    public class GitWrapper
    {
        static string FileName = @"C:\Program Files\Git" + @"\bin\git.exe";

        public delegate void Return(bool succes, string error);

        public class ReturnData
        {
            public string output;
        }

        public static Task<bool> ExecuteProcess(string dir, string command, Return returnDelegate)
        {
            ReturnData returnData = new ReturnData { output = ""};

            ProcessStartInfo gitInfo = new ProcessStartInfo()
            {
                CreateNoWindow = true,
                RedirectStandardError = true,
                RedirectStandardOutput = true,
                FileName = FileName,
                UseShellExecute = false,
                Arguments = command, // such as "fetch orign"
                WorkingDirectory = dir
            };

            Process gitProcess = new Process
            {
                StartInfo = gitInfo
            };
            gitProcess.ErrorDataReceived += (s,e)=>GitProcess_ErrorDataReceived(s,e,returnData);
            gitProcess.OutputDataReceived += (s, e) => GitProcess_OutputDataReceived(s, e, returnData);
            gitProcess.Exited += GitProcess_Exited;

            App.Current.Dispatcher.Invoke(() =>
            {
                IceConsole.OpenConsole();
            });


            //THIS IS THE PROBLEM PART
            Task<bool> task = new Task<bool>(async() => { return await RunCommandTask(gitProcess, returnDelegate, returnData); });


            return task;
        }

        static async Task<bool> RunCommandTask(Process process, Return returnDelegate, ReturnData returnData)
        {
            var tcs = new TaskCompletionSource<bool>();

            process.Start();
            process.BeginErrorReadLine();
            process.BeginOutputReadLine();
            process.WaitForExit();

            //Console.WriteLine("fineshed");
            bool succes = false;
            if (process.ExitCode == 0)
            {
                succes = true;
            }
            returnDelegate(succes, returnData.output);

            return tcs.Task.Result;

            return succes;
        }


        private static void GitProcess_ErrorDataReceived(object sender, DataReceivedEventArgs e,ReturnData returnData)
        {
            if (e.Data != null)
            {
                IceConsole.WriteLine("[Git] "+e.Data);
                returnData.output += e.Data + "\n";
            }

            //Console.WriteLine(e.Data);
        }

        private static void GitProcess_OutputDataReceived(object sender, DataReceivedEventArgs e, ReturnData returnData)
        {
            if (e.Data != null)
            {
                IceConsole.WriteLine("[Git] "+e.Data);
                returnData.output += e.Data + "\n";
            }
            //Console.WriteLine(e.Data);
        }

        private static void GitProcess_Exited(object sender, EventArgs e)
        {
            //IceConsole.WriteLine(e.Data);
            Console.WriteLine("fineshed");
        }


        public static Task Clone(string dir, string url, Return returnDelegate)
        {
            return ExecuteProcess(dir, "clone " + url, (e, d) => DefaultEndHandler(e,d,returnDelegate));
        }

        public static Task Help()
        {
            return ExecuteProcess("", "help", (e, d) => { });
        }

        public static async Task Status(string dir, Return returnDelegate)
        {
            await ExecuteProcess(dir, "status", (e, d) => DefaultEndHandler(e, d, returnDelegate));
        }

        public static Task GetCurrentCommit(string dir, Return returnDelegate)
        {
            return ExecuteProcess(dir, "rev-parse HEAD", (e, d) => DefaultEndHandler(e, d, returnDelegate));
        }

        public static Task GetCurrentCommitShort(string dir, Return returnDelegate)
        {
            return ExecuteProcess(dir, "rev-parse --short HEAD", (e, d) => DefaultEndHandler(e, d, returnDelegate));
        }

        public static Task GetCurrentCommitText(string dir, Return returnDelegate)
        {
            return ExecuteProcess(dir, "log -1 --pretty=%B", (e, d) => DefaultEndHandler(e, d, returnDelegate));
        }

        public static Task GetCurrentBranchName(string dir, Return returnDelegate)
        {
            return ExecuteProcess(dir, "rev-parse --abbrev-ref HEAD", (e, d) => DefaultEndHandler(e, d, returnDelegate));
        }

        public static Task GetChangedFiles(string dir, Return returnDelegate)
        {
            return ExecuteProcess(dir, "ls-files --other --exclude-standard", (e, d) => DefaultEndHandler(e, d, returnDelegate));
        }

        public static Task ResetFile(string dir,string file, Return returnDelegate)
        {
            return ExecuteProcess(dir, "checkout -- " + file, (e, d) => DefaultEndHandler(e, d, returnDelegate));
        }

        public static async Task<bool> CheckFileTracking(string dir, string file, Return returnDelegate)
        {
            return await ExecuteProcess(dir, "ls-files --error-unmatch " + file, (e, d) => DefaultEndHandler(e, d, returnDelegate));
        }

        public static void DefaultEndHandler(bool succes, string error, Return returnHandler)
        {
            returnHandler?.Invoke(succes, error);

            if (succes)
            {
                if (Properties.Settings.Default.CloseConsole)
                {
                    App.Current.Dispatcher.Invoke(() =>
                    {
                        IceConsole.CloseConsole();
                    });
                }
            }

        }
    }
}