package edu.pdx.cs410J.grader;

import com.google.common.annotations.VisibleForTesting;
import edu.pdx.cs410J.ParserException;
import edu.pdx.cs410J.grader.gradebook.Student;
import edu.pdx.cs410J.grader.gradebook.XmlStudentParser;
import jakarta.activation.DataHandler;
import jakarta.activation.DataSource;
import jakarta.activation.FileDataSource;
import jakarta.mail.MessagingException;
import jakarta.mail.Multipart;
import jakarta.mail.Transport;
import jakarta.mail.internet.*;

import java.io.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.format.FormatStyle;
import java.util.*;
import java.util.jar.Attributes;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * This class is used to submit assignments in CS410J.  The user
 * specified his or her email address as well as the base directory
 * for his/her source files on the command line.  The directory is
 * searched recursively for files that are allowed to be submitted.
 * Those files are
 * placed in a zip file and emailed to the grader.  A confirmation
 * email is sent to the submitter.
 *
 * More information about the JavaMail API can be found at:
 *
 * <a href="http://java.sun.com/products/javamail">
 * http://java.sun.com/products/javamail</a>
 *
 * @author David Whitlock
 * @since Fall 2000 (Refactored to use fewer static methods in Spring 2006)
 */
public class Submit extends EmailSender {

  private static final PrintWriter out = new PrintWriter(System.out, true);
  private static final PrintWriter err = new PrintWriter(System.err, true);

  /////////////////////  Instance Fields  //////////////////////////

  /**
   * The name of the project being submitted
   */
  private String projName = null;

  /**
   * The name of the user (student) submits the project
   */
  private String userName = null;

  /**
   * The submitter's email address
   */
  private String userEmail = null;

  /**
   * The submitter's user id
   */
  private String userId = null;

  /**
   * A comment describing the project
   */
  private String comment = null;

  /**
   * Should the execution of this program be logged?
   */
  private boolean debug = false;

  /**
   * Should the generated zip file be saved?
   */
  private boolean saveZip = false;

  private boolean sendEmails = true;

  /**
   * The time at which the project was submitted
   */
  private LocalDateTime submitTime = null;

  /**
   * The names of the files to be submitted
   */
  private final Set<String> fileNames = new HashSet<>();

  private boolean isSubmittingKoans = false;
  private boolean sendReceipt = true;
  private String studentXmlFileName;
  private Double estimatedHours;
  private final CurrentTimeProvider currentTimeProvider;
  private BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

  ///////////////////////  Constructors  /////////////////////////

  /**
   * Creates a new <code>Submit</code> program
   */
  Submit() {
    this(LocalDateTime::now);
  }

  @VisibleForTesting
  Submit(CurrentTimeProvider currentTimeProvider) {
    this.currentTimeProvider = currentTimeProvider;
  }

  /////////////////////  Instance Methods  ///////////////////////

  /**
   * Sets the name of the SMTP server that is used to send emails
   */
  void setEmailServerHostName(String serverName) {
    EmailSender.serverName = serverName;
  }

  /**
   * Sets whether or not the progress of the submission should be logged.
   */
  public void setDebug(boolean debug) {
    this.debug = debug;
  }

  /**
   * Sets whether or not the zip file generated by the submission
   * should be saved.
   */
  private void saveZip() {
    this.saveZip = true;
  }

  private void doNotSendEmails() {
    this.sendEmails = false;
  }

  /**
   * Sets the comment for this submission
   */
  private void setComment(String comment) {
    this.comment = comment;
  }

  /**
   * Sets the name of project being submitted
   */
  void setProjectName(String projName) {
    this.projName = projName;
  }

  /**
   * Adds the file with the given name to the list of files to be
   * submitted.
   */
  void addFile(String fileName) {
    this.fileNames.add(fileName);
  }

  /**
   * Validates the state of this submission
   *
   * @throws IllegalStateException If any state is incorrect or missing
   */
  private void validate() {
    validateProjectName();

    if (projName == null) {
      throw new IllegalStateException("Missing project name");
    }

    validateStudentXmlFile();

    if (userName == null) {
      throw new IllegalStateException("Missing student name");
    }

    if (userId == null) {
      throw new IllegalStateException("Missing login id");
    }

    if (isNineDigitStudentId(userId)) {
      throw new IllegalStateException(loginIdShouldNotBeStudentId(userId));
    }

    if (looksLikeAnEmailAddress(userId)) {
      throw new IllegalStateException(loginIdShouldNotBeEmailAddress(userId));
    }

    if (userEmail == null) {
      throw new IllegalStateException("Missing email address");

    } else {
      // Make sure user's email is okay
      try {
        new InternetAddress(userEmail);

      } catch (AddressException ex) {
        String m = "Invalid email address: " + userEmail;
        throw new IllegalStateException(m, ex);
      }
    }
  }

  private void validateStudentXmlFile() {
    if (this.studentXmlFileName == null) {
      throw new IllegalStateException("Missing Student XML File");
    }

    File studentXmlFile = new File(this.studentXmlFileName);
    if (!studentXmlFile.exists()) {
      throw new IllegalStateException("Student XML file \"" + studentXmlFile + "\" doesn't exist");
    }

    Student student;
    try {
      student = new XmlStudentParser(studentXmlFile).parseStudent();
    } catch (ParserException | IOException ex) {
      throw new IllegalStateException("Could not parse Student XML file \"" + studentXmlFile + "\"", ex);
    }

    setStudent(student);

  }

  @VisibleForTesting
  void setStudent(Student student) {
    this.userId = student.getId();
    this.userName = student.getFirstName() + " " + student.getLastName();
    this.userEmail = student.getEmail();
  }

  private String loginIdShouldNotBeEmailAddress(String userId) {
    return "Your login id (" + userId + ") should not be an email address";
  }

  @VisibleForTesting
  boolean looksLikeAnEmailAddress(String userId) {
    return userId.contains("@");
  }

  @VisibleForTesting
  boolean isNineDigitStudentId(String userId) {
    return userId.matches("^[0-9]{9}$");
  }

  private String loginIdShouldNotBeStudentId(String userId) {
    return "Your login id (" + userId + ") should not be your 9-digit student id";
  }

  @VisibleForTesting
  void validateProjectName() {
    List<String> validProjectNames = fetchListOfValidProjectNames();
    if (!validProjectNames.contains(projName)) {
      String message = "\"" + projName + "\" is not in the list of valid project names: " + validProjectNames;
      throw new IllegalStateException(message);
    }
  }

  private List<String> fetchListOfValidProjectNames() {
    return fetchListOfStringsFromResource("project-names");
  }

  private List<String> fetchListOfStringsFromResource(String resourceName) {
    InputStream stream = this.getClass().getResourceAsStream(resourceName);
    if (stream == null) {
      throw new IllegalStateException("Cannot load " + resourceName);
    }

    List<String> strings = new ArrayList<>();
    try {

      InputStreamReader isr = new InputStreamReader(stream);
      BufferedReader br = new BufferedReader(isr);
      while (br.ready()) {
        strings.add(br.readLine().trim());
      }

    } catch (IOException ex) {
      err.println("** WARNING: Problems while reading " + resourceName + ": " + ex.getMessage());
    }

    return strings;
  }

  /**
   * Submits the project to the grader
   *
   * @param verify Should the user be prompted to verify his submission?
   * @return Whether or not the submission actually occurred
   * @throws IllegalStateException If no source files were found
   */
  public boolean submit(boolean verify) throws IOException, MessagingException {
    // Recursively search the source directory for .java files
    Set<File> sourceFiles = searchForSourceFiles(fileNames);

    db(sourceFiles.size() + " source files found");

    if (sourceFiles.size() == 0) {
      String s = "No source files were found.";
      throw new IllegalStateException(s);
    } else if (sourceFiles.size() < 3) {
      String s = "Too few source files were submitted. Each project requires at least 3 files be" + 
                 " submitted. You only submitted " + sourceFiles.size() + " files";
      throw new IllegalStateException(s);
    }

    // Verify submission with user
    if (verify && !verifySubmission(sourceFiles)) {
      // User does not want to submit
      return false;
    }

    // Timestamp
    this.submitTime = this.currentTimeProvider.getCurrentTime();

    // Create a temporary zip file to hold the source files
    File zipFile = makeZipFileWith(sourceFiles);

    if (this.sendEmails) {
      // Send the zip file as an email attachment to the TA
      mailTA(zipFile, sourceFiles);

      if (sendReceipt) {
        mailReceipt(sourceFiles);
      }
    }

    return true;
  }

  private void askForEstimatedHours() {
    out.println("\nTo help inform how future students plan their approach to this project, you can");
    out.println("record the approximate number of hours you spent on this project. This estimate");
    out.println("is completely optional, is used for informational purposes only, has no impact");
    out.println("on your grade, and will only be shared with others as part of an aggregate");
    out.println("summary report.\n");

    while (true) {
      out.print("About how many hours did you spend on this project?  ");
      out.flush();

      try {
        String line = in.readLine();
        if (line == null || line.isEmpty()) {
          return;
        }

        try {
          double estimatedHours = Double.parseDouble(line.trim());
          this.setEstimatedHours(estimatedHours);
          return;

        } catch (NumberFormatException ex) {
          out.println("** Please enter a valid number or a blank line to opt out");
        }

      } catch (IOException ex) {
        err.println("** Exception while reading from System.in: " + ex);
      }
    }

  }

  /**
   * Prints debugging output.
   */
  private void db(String s) {
    if (this.debug) {
      err.println("++ " + s);
    }
  }

  /**
   * Searches for the files given on the command line.  Ignores files
   * that do not end in .java, or that appear on the "no submit" list.
   * Files must reside in a directory named
   * edu/pdx/cs410J/<studentId>.
   */
  private Set<File> searchForSourceFiles(Set<String> fileNames) {
    // Files should be sorted by name
    SortedSet<File> files =
      new TreeSet<>(Comparator.comparing(File::toString));
    populateWithFilesFromSubdirectories(files, fileNames);

    files.removeIf((file) -> !canBeSubmitted(file));

    return files;
  }

  private void populateWithFilesFromSubdirectories(SortedSet<File> allFiles, Set<String> fileNames) {
    populateWithFilesFromSubdirectories(allFiles, fileNames.stream().map(name -> new File(name).getAbsoluteFile()));
  }

  private void populateWithFilesFromSubdirectories(SortedSet<File> allFiles, Stream<File> files) {
    files.forEach((file) -> {
      if (file.isDirectory()) {
        populateWithFilesFromSubdirectories(allFiles, Arrays.stream(Objects.requireNonNull(file.listFiles())));

      } else {
        allFiles.add(file);
      }
    });

  }

  protected boolean canBeSubmitted(File file) {
    if (!fileExists(file)) {
      return false;
    }

    // Is the file on the "no submit" list?
    List<String> noSubmit = fetchListOfFilesThatCanNotBeSubmitted();
    String name = file.getName();
    if (noSubmit.contains(name)) {
      err.println("** Not submitting file " + file +
        " because it is on the \"no submit\" list");
      return false;
    }

    // Verify that file is in the correct directory.
    if (isInAKoansDirectory(file)) {
      if (!file.getName().endsWith(".java")) {
        err.println("** Not submitting file " + file +
          " because does end in \".java\"");
        return false;
      }

    } else {
      if (!isInMavenProjectDirectory(file)) {
        err.println("** Not submitting file " + file +
          ": it does not reside in a Maven project in a directory named " +
          "edu" + File.separator + "pdx" + File.separator +
          "cs410J" + File.separator + userId + " (or in one of the koans directories)");
        return false;
      }

      // Does the file name end in .java?
      if (!canFileBeSubmitted(file)) {
        String fileName = file.getName();
        int index = fileName.lastIndexOf('.');
        if (index < 0) {
          err.println("** Not submitting file " + file +
            " because it does not have an extension.");

        } else {
          String fileExtension = fileName.substring(index);
          err.println("** Not submitting file " + file +
            " because files ending in " + fileExtension +
            " are not supposed to be in that directory");
        }
        return false;
      }
    }
    return true;
  }

  @VisibleForTesting
  static boolean canFileBeSubmitted(File file) {
    String path = file.getPath();

    if (path.matches(".*src/.*/java/.*")) {
      return path.endsWith(".java");

    } else if (path.matches(".*src/.*/javadoc/.*")) {
      return path.endsWith(".html");

    } else if (path.matches(".*src/.*/resources/.*")) {
      return path.endsWith(".xml") || path.endsWith(".txt");

    } else {
      return false;
    }
  }

  boolean fileExists(File file) {
    if (!file.exists()) {
      err.println("** Not submitting file " + file +
        " because it does not exist");
      return false;
    }
    return true;
  }

  private boolean isInAKoansDirectory(File file) {
    boolean isInAKoansDirectory = hasParentDirectories(file, "beginner") ||
      hasParentDirectories(file, "intermediate") ||
      hasParentDirectories(file, "advanced") ||
      hasParentDirectories(file, "java7") ||
      hasParentDirectories(file, "java8");
    if (isInAKoansDirectory) {
      this.isSubmittingKoans = true;
      db(file + " is in a koans directory");
    }
    return isInAKoansDirectory;
  }

  @VisibleForTesting
  boolean isInMavenProjectDirectory(File file) {
    boolean isInMavenProjectDirectory = hasParentDirectories(file, userId, "cs410J", "pdx", "edu", "java|javadoc|resources", "main|test|it", "src");
    if (isInMavenProjectDirectory) {
      db(file + " is in the edu/pdx/cs410J directory");
    }
    return isInMavenProjectDirectory;
  }

  private boolean hasParentDirectories(File file, String... parentDirectoryNames) {
    File parent = file.getParentFile();

    // Skip over subpackages
    while (parent != null && !parent.getName().equals(parentDirectoryNames[0])) {
      parent = parent.getParentFile();
    }

    for (String parentDirectoryName : parentDirectoryNames) {
      if (parent == null || !parent.getName().matches(parentDirectoryName)) {
        return false;

      } else {
        parent = parent.getParentFile();
      }
    }

    return true;
  }

  private List<String> fetchListOfFilesThatCanNotBeSubmitted() {
    return fetchListOfStringsFromResource("no-submit");
  }

  /**
   * Prints a summary of what is about to be submitted and prompts the
   * user to verify that it is correct.
   *
   * @return <code>true</code> if the user wants to submit
   */
  private boolean verifySubmission(Set<File> sourceFiles) {
    // Print out what is going to be submitted
    out.print("\n" + userName);
    out.print("'s submission for ");
    out.println(projName);

    for (File file : sourceFiles) {
      out.println("  " + file);
    }

    if (comment != null) {
      out.println("\nComment: " + comment + "\n\n");
    }

    out.println("A receipt will be sent to: " + userEmail + "\n");

    warnIfMainProjectClassIsNotSubmitted(sourceFiles);

    warnIfTestClassesAreNotSubmitted(sourceFiles);

    askForEstimatedHours();

    return doesUserWantToSubmit();
  }

  protected void warnIfMainProjectClassIsNotSubmitted(Set<File> sourceFiles) {
    boolean wasMainProjectClassSubmitted = sourceFiles.stream().anyMatch((f) -> f.getName().contains(this.projName));
    if (!wasMainProjectClassSubmitted && !this.isSubmittingKoans) {
      String mainProjectClassName = this.projName + ".java";
      out.println("*** WARNING: You are submitting " + this.projName +
        ", but did not include " + mainProjectClassName + ".\n" +
        "    You might want to check the name of the project or the files you are submitting.\n");
    }
  }

  protected void warnIfTestClassesAreNotSubmitted(Set<File> sourceFiles) {
    boolean wereTestClassessSubmitted = submittedTestClasses(sourceFiles);
    if (!wereTestClassessSubmitted && !this.isSubmittingKoans) {
      out.println("*** WARNING: You are not submitting a \"test\" directory.\n" +
        "    Your unit tests are executed as part of the grading of your project.\n");
    }
  }

  @VisibleForTesting
  static boolean submittedTestClasses(Set<File> sourceFiles) {
    return sourceFiles.stream().anyMatch((f) -> f.getPath().contains("test"));
  }

  private boolean doesUserWantToSubmit() {
    while (true) {
      out.print("\nDo you wish to continue with the submission? (yes/no) ");
      out.flush();

      try {
        String line = in.readLine().trim();
        switch (line) {
          case "yes":
            return true;

          case "no":
            return false;

          default:
            err.println("** Please enter yes or no");
            break;
        }

      } catch (IOException ex) {
        err.println("** Exception while reading from System.in: " + ex);
      }
    }
  }

  /**
   * Returns the name of a <code>File</code> relative to the source
   * directory.
   */
  protected String getZipEntryNameFor(File file) {
    if (isSubmittingKoans) {
      return file.getParentFile().getName() + "/" + file.getName();

    } else {
      // We already know that the file is in the correct directory
      return getZipEntryNameFor(file.getPath());
    }
  }

  @VisibleForTesting
  static String getZipEntryNameFor(String filePath) {
    Pattern pattern = Pattern.compile(".*/src/(main|test|it)/(java|javadoc|resources)/edu/pdx/cs410J/(.*)");
    Matcher matcher = pattern.matcher(filePath);

    if (matcher.matches()) {
      return "src/" + matcher.group(1) + "/" + matcher.group(2) + "/edu/pdx/cs410J/" + matcher.group(3);
    } else {
      throw new IllegalStateException("Can't extract zip entry name for " + filePath);
    }
  }

  /**
   * Creates a Zip file that contains the source files.  The Zip File
   * is temporary and is deleted when the program exits.
   */
  private File makeZipFileWith(Set<File> sourceFiles) throws IOException {
    String zipFileName = userName.replace(' ', '_') + "-TEMP";
    File zipFile = File.createTempFile(zipFileName, ".zip");
    if (!saveZip) {
      zipFile.deleteOnExit();

    } else {
      out.println("Saving temporary Zip file: " + zipFile);
    }

    db("Created Zip file: " + zipFile);

    Map<File, String> sourceFilesWithNames =
      sourceFiles.stream().collect(Collectors.toMap(file -> file, this::getZipEntryNameFor));

    new ZipFileOfFilesMaker(sourceFilesWithNames, zipFile, getManifestEntries()).makeZipFile();
    return zipFile;
  }

  private Map<Attributes.Name, String> getManifestEntries() {
    Map<Attributes.Name, String> manifestEntries = new HashMap<>();
    manifestEntries.put(ManifestAttributes.USER_NAME, userName);
    manifestEntries.put(ManifestAttributes.USER_ID, userId);
    manifestEntries.put(ManifestAttributes.USER_EMAIL, userEmail);
    manifestEntries.put(ManifestAttributes.PROJECT_NAME, projName);
    manifestEntries.put(ManifestAttributes.SUBMISSION_COMMENT, comment);
    manifestEntries.put(ManifestAttributes.SUBMISSION_TIME, ManifestAttributes.formatSubmissionTime(submitTime));
    if (estimatedHours != null) {
      manifestEntries.put(ManifestAttributes.ESTIMATED_HOURS, String.valueOf(estimatedHours));
    }
    return manifestEntries;
  }

  /**
   * Sends the Zip file to the TA as a MIME attachment.  Also includes
   * a textual summary of the contents of the Zip file.
   */
  private void mailTA(File zipFile, Set<File> sourceFiles) throws MessagingException {
    MimeMessage message =
      newEmailTo(newEmailSession(debug), TA_EMAIL)
        .from(userEmail, userName)
        .withSubject("CS410J-SUBMIT " + userName + "'s " + projName)
        .createMessage();

    MimeBodyPart textPart = createTextPartOfTAEmail(sourceFiles);
    MimeBodyPart filePart = createZipAttachment(zipFile);

    Multipart mp = new MimeMultipart();
    mp.addBodyPart(textPart);
    mp.addBodyPart(filePart);

    message.setContent(mp);

    out.println("Submitting project to Grader");

    Transport.send(message);
  }

  private MimeBodyPart createZipAttachment(File zipFile) throws MessagingException {
    // Now attach the Zip file
    DataSource ds = new FileDataSource(zipFile) {
      @Override
      public String getContentType() {
        return "application/zip";
      }
    };
    DataHandler dh = new DataHandler(ds);
    MimeBodyPart filePart = new MimeBodyPart();

    String zipFileTitle = getZipFileTitle();

    filePart.setDataHandler(dh);
    filePart.setFileName(zipFileTitle);
    filePart.setDescription(userName + "'s " + projName);

    return filePart;
  }

  @VisibleForTesting
  String getZipFileTitle() {
    return userName.replace(' ', '_') + ".zip";
  }

  private MimeBodyPart createTextPartOfTAEmail(Set<File> sourceFiles) throws MessagingException {
    // Create the text portion of the message
    StringBuilder text = new StringBuilder();
    text.append("Student name: ").append(userName).append(" (").append(userEmail).append(")\n");
    text.append("Project name: ").append(projName).append("\n");
    text.append("Submitted on: ").append(humanReadableSubmitDate()).append("\n");
    if (comment != null) {
      text.append("\nComment: ").append(comment).append("\n\n");
    }
    text.append("Contents:\n");

    for (File file : sourceFiles) {
      text.append("  ").append(getZipEntryNameFor(file)).append("\n");
    }
    text.append("\n\n");

    MimeBodyPart textPart = new MimeBodyPart();
    textPart.setContent(text.toString(), "text/plain");

    // Try not to display text as separate attachment
    textPart.setDisposition("inline");
    return textPart;
  }

  private String humanReadableSubmitDate() {
    return submitTime.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL, FormatStyle.MEDIUM));
  }

  /**
   * Sends a email to the user as a receipt of the submission.
   */
  private void mailReceipt(Set<File> sourceFiles) throws MessagingException {
    String subject = "CS410J " + projName + " submission";
    InternetAddress email = newInternetAddress(this.userEmail, this.userName);
    MimeMessage message =
      newEmailTo(newEmailSession(debug), email)
        .from(TA_EMAIL)
        .replyTo(DAVE_EMAIL)
        .withSubject(subject)
        .createMessage();

    // Create the contents of the message
    StringBuilder text = new StringBuilder();
    text.append("On ").append(humanReadableSubmitDate()).append("\n");
    text.append(userName).append(" (").append(userEmail).append(")\n");
    text.append("submitted the following files for ").append(projName).append(":\n");

    for (File file : sourceFiles) {
      text.append("  ").append(file.getAbsolutePath()).append("\n");
    }

    if (comment != null) {
      text.append("\nComment: ").append(comment).append("\n\n");
    }

    text.append("\n\n");
    text.append("Have a nice day.");

    // Add the text to the message and send it
    message.setText(text.toString());
    message.setDisposition("inline");

    out.println("Sending receipt to you at " + userEmail);

    Transport.send(message);
  }

  /////////////////////////  Main Program  ///////////////////////////

  /**
   * Prints usage information about this program.
   */
  protected void usage(String message) {
    err.println("\n** " + message + "\n");
    err.println("usage: java " + this.getClass().getSimpleName() + " [options] args file+");
    err.println("  args are (in this order):");
    err.println("    project            What project is being submitted (Project1, Project2, etc.)");
    err.println("    studentXmlFile     XML file with info about who is submitting the project");
    err.println("    srcDirectory       Directory containing source code to submit");
    err.println("  options are (options may appear in any order):");
    err.println("    -savezip           Saves temporary Zip file");
    err.println("    -nosend            Generates zip file, but does not send emails");
    err.println("    -smtp serverName   Name of SMTP server");
    err.println("    -verbose           Log debugging output");
    err.println("    -comment comment   Info for the Grader");
    err.println("");
    err.println("Submits Java source code to the CS410J grader.");
    System.exit(1);
  }

  public static void main(String[] args) throws IOException, MessagingException {
    Submit submit = new Submit();
    submit.parseCommandLineAndSubmit(args);
  }

  /**
   * Parses the command line, finds the source files, prompts the user
   * to verify whether or not the settings are correct, and then sends
   * an email to the Grader.
   */
  void parseCommandLineAndSubmit(String[] args) throws IOException, MessagingException {
    // Parse the command line
    for (int i = 0; i < args.length; i++) {
      // Check for options first
      if (args[i].equals("-smtp")) {
        if (++i >= args.length) {
          usage("No SMTP server specified");
        }

        this.setEmailServerHostName(args[i]);

      } else if (args[i].equals("-verbose")) {
        this.setDebug(true);

      } else if (args[i].equals("-savezip")) {
        this.saveZip();

      } else if (args[i].equals("-nosend")) {
        this.doNotSendEmails();

      } else if (args[i].equals("-comment")) {
        if (++i >= args.length) {
          usage("No comment specified");
        }

        this.setComment(args[i]);

      } else if (this.projName == null) {
        this.setProjectName(args[i]);

      } else if (this.studentXmlFileName == null) {
        this.studentXmlFileName = args[i];

      } else {
        // The name of a source file
        this.addFile(args[i]);
      }
    }

    boolean submitted;

    try {
      // Make sure that user entered enough information
      this.validate();

      this.db("Command line successfully parsed.");

      submitted = this.submit(true);

    } catch (IllegalStateException ex) {
      usage(ex.getMessage());
      return;
    }

    // All done.
    if (submitted) {
      out.println(this.projName + " submitted successfully.  Thank you.");

    } else {
      out.println(this.projName + " not submitted.");
    }
  }

  void setSendReceipt(boolean sendReceipt) {
    this.sendReceipt = sendReceipt;

  }

  public void setEstimatedHours(Double estimatedHours) {
    this.estimatedHours = estimatedHours;
  }

  static class ManifestAttributes {

    static final Attributes.Name USER_NAME = new Attributes.Name("Submitter-User-Name");
    static final Attributes.Name USER_ID = new Attributes.Name("Submitter-User-Id");
    static final Attributes.Name USER_EMAIL = new Attributes.Name("Submitter-Email");
    static final Attributes.Name PROJECT_NAME = new Attributes.Name("Project-Name");
    static final Attributes.Name SUBMISSION_TIME = new Attributes.Name("Submission-Time");
    static final Attributes.Name SUBMISSION_COMMENT = new Attributes.Name("Submission-Comment");
    static final Attributes.Name ESTIMATED_HOURS = new Attributes.Name("Estimated-Hours");

    private static final DateTimeFormatter LEGACY_DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MMM-dd HH:mm:ss");
    private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ISO_DATE_TIME;

    static String formatSubmissionTime(LocalDateTime submitTime) {
      return submitTime.format(DATE_TIME_FORMATTER);
    }

    static LocalDateTime parseSubmissionTime(String string) {
      try {
        return LocalDateTime.parse(string, DATE_TIME_FORMATTER);

      } catch (DateTimeParseException ex) {
        return LocalDateTime.parse(string, LEGACY_DATE_TIME_FORMATTER);
      }
    }
  }

  @VisibleForTesting
  interface CurrentTimeProvider {
    LocalDateTime getCurrentTime();
  }
}