package edu.pdx.cs.joy.grader;

import com.google.common.annotations.VisibleForTesting;
import edu.pdx.cs.joy.grader.gradebook.Grade;
import edu.pdx.cs.joy.grader.gradebook.GradeBook;
import edu.pdx.cs.joy.grader.gradebook.Student;
import edu.pdx.cs.joy.grader.gradebook.XmlGradeBookParser;

import java.io.IOException;
import java.io.InputStream;
import java.nio.file.FileVisitOption;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Function;
import java.util.jar.Attributes;
import java.util.jar.Manifest;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;

import static edu.pdx.cs.joy.grader.TestedProjectSubmissionOutputParser.*;

public class FindUngradedSubmissions {
  private final SubmissionDetailsProvider submissionDetailsProvider;
  private final TestOutputPathProvider testOutputProvider;
  private final TestOutputDetailsProvider testOutputDetailsProvider;
  private final GradeBookProvider gradeBookProvider;

  @VisibleForTesting
  FindUngradedSubmissions(SubmissionDetailsProvider submissionDetailsProvider, TestOutputPathProvider testOutputProvider, TestOutputDetailsProvider testOutputDetailsProvider, GradeBookProvider gradeBookProvider) {
    Objects.requireNonNull(gradeBookProvider, "GradeBook provider cannot be null");
    this.submissionDetailsProvider = submissionDetailsProvider;
    this.testOutputProvider = testOutputProvider;
    this.testOutputDetailsProvider = testOutputDetailsProvider;
    this.gradeBookProvider = gradeBookProvider;
  }

  public FindUngradedSubmissions(String gradeBookXmlFile) {
    this(new SubmissionDetailsProviderFromZipFile(),
         new TestOutputProviderInParentDirectory(),
         new TestOutputDetailsProviderFromTestOutputFile(),
         new GradeBookProviderFromXmlFile(gradeBookXmlFile));
  }

  @VisibleForTesting
  SubmissionAnalysis analyzeSubmission(Path submissionPath) {
    SubmissionDetails submission = this.submissionDetailsProvider.getSubmissionDetails(submissionPath);
    Path submissionDirectory = submissionPath.getParent();
    Path testOutputPath = this.testOutputProvider.getTestOutput(submissionDirectory, submission.studentId());
    boolean needsToBeTested;
    boolean needsToBeGraded;
    boolean needsToBeRecorded;
    String reason;

    if (!Files.exists(testOutputPath)) {
      needsToBeTested = true;
      needsToBeGraded = true;
      needsToBeRecorded = false;
      reason = "Test output file does not exist: " + testOutputPath;

    } else {
      TestOutputDetails testOutput = this.testOutputDetailsProvider.getTestOutputDetails(testOutputPath);
      if (submittedAfterTesting(submission, testOutput)) {
        needsToBeTested = true;
        needsToBeGraded = true;
        needsToBeRecorded = false;
        reason = "Submission on " + submission.submissionTime() + " is after testing on " + testOutput.testedSubmissionTime();

      } else if (!testOutput.hasGrade()) {
        needsToBeTested = false;
        needsToBeGraded = !testOutput.hasBeenReviewed();
        needsToBeRecorded = false;
        reason = "Test output file does not have a grade: " + testOutputPath;

      } else {
        needsToBeTested = false;
        needsToBeGraded = false;
        needsToBeRecorded = doesCareNeedToBeRecorded(submission, testOutput);
        reason = "Test output file was graded after submission: " + testOutputPath;
      }
    }

    return new SubmissionAnalysis(submissionPath, needsToBeTested, needsToBeGraded, reason, testOutputPath, needsToBeRecorded);
  }

  private boolean doesCareNeedToBeRecorded(SubmissionDetails submission, TestOutputDetails testOutput) {
    // If test output doesn't have project name or grade, can't check
    if (testOutput.projectName() == null || testOutput.grade() == null) {
      return false;
    }

    // Get the gradebook
    java.util.Optional<GradeBook> gradeBookOpt = gradeBookProvider.getGradeBook();
    if (gradeBookOpt.isEmpty()) {
      return false;
    }

    GradeBook gradeBook = gradeBookOpt.get();

    // Get the student from the gradebook
    Optional<Student> studentOpt = gradeBook.getStudent(submission.studentId());
    if (studentOpt.isEmpty()) {
      return false; // Student not in gradebook, nothing to record
    }

    Student student = studentOpt.get();

    // Get the grade for the assignment
    Grade grade = student.getGrade(testOutput.projectName());
    if (grade == null) {
      return true; // No grade recorded for this assignment
    }

    // Compare grades - if different, needs to be recorded
    return grade.getScore() != testOutput.grade();
  }

  private static boolean submittedAfterTesting(SubmissionDetails submission, TestOutputDetails testOutput) {
    LocalDateTime submissionTime = submission.submissionTime();
    LocalDateTime testedSubmissionTime = testOutput.testedSubmissionTime();
    return submissionTime.isAfter(testedSubmissionTime.plusMinutes(1L));
  }

  @VisibleForTesting
  record SubmissionDetails(String studentId, LocalDateTime submissionTime) {

  }

  public static void main(String[] args) {
    if (args.length == 0) {
      System.err.println("Usage: java FindUngradedSubmissions -includeReason gradeBookXmlFile submissionZipOrDirectory+");
      return;
    }

    boolean includeReason = false;
    List<String> fileNames = new ArrayList<>();

    for (String arg : args) {
      if (arg.equals("-includeReason")) {
        includeReason = true;

      } else if (arg.startsWith("-")) {
        System.err.println("Unknown option: " + arg);
        return;

      } else {
        fileNames.add(arg);
      }
    }

    // First non-option argument is the required gradebook XML file
    if (fileNames.isEmpty()) {
      System.err.println("Missing required gradebook XML file");
      System.err.println("Usage: java FindUngradedSubmissions -includeReason gradeBookXmlFile submissionZipOrDirectory+");
      return;
    }

    String gradeBookXmlFile = fileNames.removeFirst();

    // Validate that the gradebook XML file can be parsed
    try {
      XmlGradeBookParser parser = new XmlGradeBookParser(gradeBookXmlFile);
      parser.parse(); // This will throw an exception if the file is invalid
    } catch (Exception e) {
      System.err.println("Error: The first argument must be a valid gradebook XML file");
      System.err.println("Cannot parse gradebook from: " + gradeBookXmlFile);
      System.err.println("Error: " + e.getMessage());
      return;
    }

    Stream<Path> submissions = findSubmissionsIn(fileNames);
    FindUngradedSubmissions finder = new FindUngradedSubmissions(gradeBookXmlFile);
    Stream<SubmissionAnalysis> analyses = submissions.map(finder::analyzeSubmission);
    List<SubmissionAnalysis> needsToBeTested = new ArrayList<>();
    List<SubmissionAnalysis> needsToBeGraded = new ArrayList<>();
    List<SubmissionAnalysis> gradeNeedsToBeRecorded = new ArrayList<>();

    analyses.forEach(analysis -> {
      if (analysis.needsToBeTested()) {
        needsToBeTested.add(analysis);

      } else if (analysis.needsToBeGraded()) {
        needsToBeGraded.add(analysis);

      } else if (analysis.gradeNeedsToBeRecorded()) {
        gradeNeedsToBeRecorded.add(analysis);
      }
    });

    printOutAnalyses(needsToBeTested, "tested", SubmissionAnalysis::submission, includeReason);
    printOutAnalyses(needsToBeGraded, "graded", SubmissionAnalysis::testOutput, includeReason);
    printOutAnalyses(gradeNeedsToBeRecorded, "recorded", SubmissionAnalysis::testOutput, includeReason);
  }

  private static void printOutAnalyses(List<SubmissionAnalysis> analyses, String action, Function<SubmissionAnalysis, Path> getPath, boolean includeReason) {
    int size = analyses.size();
    String description = (size == 1 ? " submission needs" : " submissions need");
    System.out.println(size + description + " to be " + action + ": ");
    analyses.forEach(analysis -> {
      System.out.print("  " + getPath.apply(analysis));
      if (includeReason) {
        System.out.print("   " + analysis.reason);
      }
      System.out.println();
    });
  }

  private static Stream<Path> findSubmissionsIn(List<String> fileNames) {
    return fileNames.stream()
        .map(Path::of)
        .filter(Files::exists)
        .flatMap(FindUngradedSubmissions::findSubmissionsIn);
  }

  private static Stream<? extends Path> findSubmissionsIn(Path path) {
    if (Files.isDirectory(path)) {
      try {
        // If we put the walk into a try-with-resources, the consumer of the stream will encounter and
        // exception, because the stream will be closed immediately.
        Stream<Path> walk = Files.walk(path, FileVisitOption.FOLLOW_LINKS);
        return walk.filter(FindUngradedSubmissions::isZipFile);

      } catch (IOException e) {
        throw new RuntimeException("Error while walking through directory: " + path, e);
      }
    } else if (isZipFile(path)) {
      return Stream.of(path);
    } else {
      return Stream.empty();
    }
  }

  private static boolean isZipFile(Path p) {
    return Files.isRegularFile(p) && p.getFileName().toString().endsWith(".zip");
  }

  interface SubmissionDetailsProvider {
    SubmissionDetails getSubmissionDetails(Path submission);
  }

  interface TestOutputPathProvider {
    Path getTestOutput(Path submissionDirectory, String studentId);
  }

  interface TestOutputDetailsProvider {
    TestOutputDetails getTestOutputDetails(Path testOutput);
  }

  interface GradeBookProvider {
    java.util.Optional<GradeBook> getGradeBook();
  }

  @VisibleForTesting
  record TestOutputDetails(Path testOutput, LocalDateTime testedSubmissionTime, boolean hasGrade, String projectName, Double grade, boolean hasBeenReviewed) {
  }

  @VisibleForTesting
  record SubmissionAnalysis (Path submission, boolean needsToBeTested, boolean needsToBeGraded, String reason, Path testOutput, boolean gradeNeedsToBeRecorded) {

  }

  private static class SubmissionDetailsProviderFromZipFile implements SubmissionDetailsProvider {
    @Override
    public SubmissionDetails getSubmissionDetails(Path submission) {
      try (InputStream zipFile = Files.newInputStream(submission)) {
        Manifest manifest = ProjectSubmissionsProcessor.getManifestFromZipFile(zipFile);
        return getSubmissionDetails(manifest);

      } catch (IOException | StudentEmailAttachmentProcessor.SubmissionException e) {
        throw new RuntimeException(e);
      }
    }

    private SubmissionDetails getSubmissionDetails(Manifest manifest) throws StudentEmailAttachmentProcessor.SubmissionException {
      Attributes attrs = manifest.getMainAttributes();
      String studentId = ProjectSubmissionsProcessor.getStudentIdFromManifestAttributes(attrs);
      LocalDateTime submissionTime = ProjectSubmissionsProcessor.getSubmissionTime(attrs);
      return new SubmissionDetails(studentId, submissionTime);
    }
  }

  private static class TestOutputProviderInParentDirectory implements TestOutputPathProvider {
    @Override
    public Path getTestOutput(Path submissionDirectory, String studentId) {
      return submissionDirectory.resolve(studentId + ".out");
    }
  }

  private static class GradeBookProviderFromXmlFile implements GradeBookProvider {
    private final String xmlFilePath;
    private GradeBook gradeBook;

    GradeBookProviderFromXmlFile(String xmlFilePath) {
      this.xmlFilePath = xmlFilePath;
    }

    @Override
    public java.util.Optional<GradeBook> getGradeBook() {
      if (gradeBook == null && xmlFilePath != null) {
        try {
          XmlGradeBookParser parser = new XmlGradeBookParser(xmlFilePath);
          gradeBook = parser.parse();
        } catch (Exception e) {
          String message = "Error loading gradebook from " + xmlFilePath + ": " + e.getMessage();
          System.err.println(message);
          throw new RuntimeException(message, e);
        }
      }
      return java.util.Optional.ofNullable(gradeBook);
    }
  }

  @VisibleForTesting
  static class TestOutputDetailsProviderFromTestOutputFile implements TestOutputDetailsProvider {

    public static Double parseGrade(String line) {
      if (line.contains("out of")) {
        String[] parts = line.split("out of");
        if (parts.length == 2) {
          try {
            return Double.parseDouble(parts[0].trim());
          } catch (NumberFormatException e) {
            return Double.NaN;
          }
        }
      }
      return null;
    }

    private static final Pattern PROJECT_NAME_PATTERN = Pattern.compile(".*The Joy of Coding Project (\\d+): .*");

    public static String parseProjectName(String line) {
      if (line.contains("The Joy of Coding Project")) {
        Matcher matcher = PROJECT_NAME_PATTERN.matcher(line);
        if (matcher.matches()) {
          return "Project" + matcher.group(1);
        }
      }
      return null;
    }

    @Override
    public TestOutputDetails getTestOutputDetails(Path testOutput) {
      try {
        return parseTestOutputDetails(testOutput, Files.lines(testOutput));
      } catch (IOException | TestedProjectSubmissionOutputParsingException e) {
        throw new RuntimeException("While parsing " + testOutput, e);
      }
    }

    static TestOutputDetails parseTestOutputDetails(Path testOutput, Stream<String> lines) throws TestedProjectSubmissionOutputParsingException {
      ProjectScore projectScore = parseTestedSubmissionOutput(lines);
      return new TestOutputDetails(testOutput, projectScore.getSubmissionTime(), !Double.isNaN(projectScore.getScore()), projectScore.getProjectName(), projectScore.getScore(), projectScore.isReviewed());
    }

  }
}