using System;
using System.Text;
using System.Linq;
using System.Threading.Tasks;
using KSU.CS.Pendant.Server.Models;
using Microsoft.Extensions.Configuration;
using System.IO;
using LibGit2Sharp;
using System.IO.Compression;

namespace KSU.CS.Pendant.Server.Services
{
    public class AssignmentValidationService : IAssignmentValidationService
    {
        private readonly DataContext _context;
        private readonly string _rootPath;

        public AssignmentValidationService(DataContext context, IConfiguration configuration)
        {
            _context = context;
            _rootPath = configuration["Paths:HomeDir"];
        }

        #region Interface Methods

        /// <summary>
        /// Checks the <paramref name="milestone"/> assignment for the <paramref name="user"/>,
        /// generating a new Validation that describes what work still needs to be completed.
        /// </summary>
        /// <param name="user">The user whose milestone submission should be checked</param>
        /// <param name="milestone">The milestone the submission is for</param>
        public int Check(ValidationAttempt attempt)
        {
            return CheckAsync(attempt).GetAwaiter().GetResult();
        }

        /// <summary>
        /// Checks the <paramref name="milestone"/> assignment for the <paramref name="user"/>,
        /// generating a new Validation that describes what work still needs to be completed.
        /// </summary>
        /// <param name="user">The user whose milestone submission should be checked</param>
        /// <param name="milestone">The milestone the submission is for</param>
        public async Task<int> CheckAsync(ValidationAttempt attempt)
        {
            // Validate the assignment 
            var result = await ProgramVerifier.Verifier.Check(attempt.SolutionPath, attempt.Assignment.SpecificationPath);

            // Populate the ValidationAttempt
            attempt.DateTime = DateTime.Now;
            attempt.StructuralIssues = result.StructuralIssues.Select(issue => new ValidationIssue()
            {
                Message = issue
                // TODO: add assignment url for HelpUrl
            }).ToList();
            attempt.FunctionalIssues = result.FunctionalIssues.Select(issue => new ValidationIssue()
            {
                Message = issue
            }).ToList();
            attempt.DesignIssues = result.DesignIssues.Select(issue => new ValidationIssue()
            {
                Message = issue.Message,
                HelpUrl = issue.HelpUrl,
                SourceUrl = BuildGitHubSourceUrl(attempt.RepoUrl, attempt.CommitIdentifier, issue.Path, issue.Line)
            }).ToList();
            attempt.StyleIssues = result.StyleIssues.Select(issue => new ValidationIssue()
            {
                Message = issue.Message,
                HelpUrl = issue.HelpUrl,
                SourceUrl = BuildGitHubSourceUrl(attempt.RepoUrl, attempt.CommitIdentifier, issue.Path, issue.Line)
            }).ToList();

            _context.ValidationAttempts.Add(attempt);
            await _context.SaveChangesAsync();

            return attempt.IssueCount;
        }

        /// <summary>
        /// Checks the <paramref name="milestone"/> assignment for the <paramref name="user"/>,
        /// generating a new Validation that describes what work still needs to be completed.
        /// </summary>
        /// <param name="user">The user whose milestone submission should be checked</param>
        /// <param name="milestone">The milestone the submission is for</param>
        public void CheckMilestone(User user, MilestoneAssignment milestone)
        {
            CheckMilestoneAsync(user, milestone).GetAwaiter().GetResult();
        }

        /// <summary>
        /// Checks the <paramref name="milestone"/> assignment for the <paramref name="user"/>,
        /// generating a new Validation that describes what work still needs to be completed.
        /// </summary>
        /// <param name="user">The user whose milestone submission should be checked</param>
        /// <param name="milestone">The milestone the submission is for</param>
        public async Task CheckMilestoneAsync(User user, MilestoneAssignment milestone)
        {
            var ownerName = milestone.IterativeProject.GitHubOrganizationName;
            var repoName = $"{milestone.IterativeProject.RepositoryPrefix}-{user.GitHubAccount.Username}";
            var branchName = milestone.BranchName;

            // Clone the repo
            var studentPath = CloneAndCheckout(user, milestone, ownerName, repoName, branchName);

            // Validate the assignment 
            var result = await ProgramVerifier.Verifier.Check(studentPath, milestone.SpecificationPath);

            // Create the ValidationAttempt
            var attempt = new ValidationAttempt()
            {
                User = user,
                Assignment = milestone,
                SolutionPath = studentPath,
                DateTime = DateTime.Now,
                StructuralIssues = result.StructuralIssues.Select(issue => new ValidationIssue()
                {
                    Message = issue
                    // TODO: add assignment url for HelpUrl
                }).ToList(),
                FunctionalIssues = result.FunctionalIssues.Select(issue => new ValidationIssue()
                {
                    Message = issue
                }).ToList(),
                DesignIssues = result.DesignIssues.Select(issue => new ValidationIssue()
                {
                    Message = issue.Message,
                    HelpUrl = issue.HelpUrl,
                    SourceUrl = BuildGitHubSourceUrl(ownerName, repoName, branchName, issue.Path, issue.Line)
                }).ToList(),
                StyleIssues = result.StyleIssues.Select(issue => new ValidationIssue()
                {
                    Message = issue.Message,
                    HelpUrl = issue.HelpUrl,
                    SourceUrl = BuildGitHubSourceUrl(ownerName, repoName, branchName, issue.Path, issue.Line)
                }).ToList()
            };

            _context.ValidationAttempts.Add(attempt);
            await _context.SaveChangesAsync();
        }

        /// <summary>
        /// Extracts and saves the <paramref name="assignment"/> specification into a local folder 
        /// and sets the path variable
        /// </summary>
        /// <param name="assignment">The assignment with the specification to save</param>
        /// <returns>True on success, false otherwise</returns>
        public bool SaveAssignmentSpecification(Assignment assignment)
        {
            return SaveAssignmentSpecificationAsync(assignment).GetAwaiter().GetResult();
        }

        /// <summary>
        /// Extracts and saves the <paramref name="assignment"/> specification into a local folder 
        /// and sets the path variable
        /// </summary>
        /// <param name="assignment">The assignment with the specification to save</param>
        /// <returns>True on success, false otherwise</returns>
        public async Task<bool> SaveAssignmentSpecificationAsync(Assignment assignment)
        {
            // Save the assignment specification
            try
            {
                var tmpPath = Path.GetTempFileName();
                var randomName = Path.GetRandomFileName();
                var specificationPath = Path.Combine(_rootPath, "specifications", randomName);

                using (var stream = System.IO.File.Create(tmpPath))
                {
                    await assignment.Specification.CopyToAsync(stream);
                }

                await Task.Run(() => ZipFile.ExtractToDirectory(tmpPath, specificationPath, true));

                await Task.Run(() => System.IO.File.Delete(tmpPath));

                // The unzipped file adds an extra directory - should be archive.FileName with the .zip dropped
                var dirName = Path.GetFileNameWithoutExtension(assignment.Specification.FileName);
                assignment.SpecificationPath = Path.Combine(specificationPath, dirName);
            }
            catch (Exception)
            {
                return false;
            }
            return true;
        }

        #endregion

        #region Helper Methods

        /// <summary>
        /// Helper method that:
        /// 1. Clones the repo (if it does not yet exist) and 
        /// 2. Checks out the specified branch
        /// </summary>
        /// <param name="user">The user the repository belongs to</param>
        /// <param name="assignment">The assignment which this repo is associated with</param>
        /// <param name="ownerName">The owner of the repo (typically the organization the GitHub assignment was created from)</param>
        /// <param name="repoName">The name of the repository that is being cloned</param>
        /// <param name="branchName">The name of the branch to check out</param>
        /// <returns>The path to the cloned repo</returns>
        private string CloneAndCheckout(User user, Assignment assignment, string ownerName, string repoName, string branchName)
        {

            // git@github.com:ksu-cis/webhook-test-zombiepaladin.git
            var filePath = $"{_rootPath}\\submissions\\{assignment.ID}\\{user.ID}";
            var repoUrl = $"git@github.com:{ownerName}/{repoName}.git";

            // Clone the repo if it does not yet exist
            if (!Directory.Exists(filePath))
            {
                Directory.CreateDirectory(filePath);
                Repository.Clone(repoUrl, filePath);
            }

            using var repo = new Repository(filePath);

            // Create a local branch to track the remote one if it does not yet exist
            if (repo.Branches[branchName] is null)
            {
                Branch trackedBranch = repo.Branches[$"refs/remotes/origin/{branchName}"];
                Branch localBranch = repo.CreateBranch(branchName, trackedBranch.Tip);
                repo.Branches.Update(localBranch, b => b.TrackedBranch = trackedBranch.CanonicalName);
            }

            // Checkout the specified branch
            var branch = repo.Branches[branchName];
            if (branch != null) Commands.Checkout(repo, branch);

            return filePath;
        }

        /// <summary>
        /// A helper method to build a URL pointing at the specified <paramref name="line"/> number 
        /// in the file at <paramref name="path"/> in the branch <paramref name="branchName"/> found
        /// in the repo <paramref name="repoName"/> in the oranization <paramref name="ownerName"/>.
        /// </summary>
        /// <param name="ownerName">The organization that owns the repo</param>
        /// <param name="repoName">The name of the repo</param>
        /// <param name="branchName">The repo branch of interest</param>
        /// <param name="path">The path to the file of interest</param>
        /// <param name="line">The line number of that file to highlight</param>
        /// <returns></returns>
        private static string BuildGitHubSourceUrl(string ownerName, string repoName, string branchName, string path, string line)
        {
            if (path.Length == 0) return "";
            // Build the souceURL 
            var sb = new StringBuilder();
            sb.Append("https://github.com/");
            sb.Append(ownerName);
            sb.Append("/");
            sb.Append(repoName);
            sb.Append("/blob/");
            sb.Append(branchName);
            sb.Append(path);
            sb.Append("#L");
            sb.Append(line);
            return sb.ToString();
        }

        private static string BuildGitHubSourceUrl(string repoUrl, string commitIdentifier, string path, string line)
        {
            if (path.Length == 0) return "";
            // Build the souceURL 
            var sb = new StringBuilder();
            sb.Append(repoUrl);
            sb.Append("/tree/");
            sb.Append(commitIdentifier);
            sb.Append(path);
            sb.Append("#L");
            sb.Append(line);
            return sb.ToString();
        }

        #endregion
    }
}