/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.commons.net.ftp.parser;
  
  import static org.junit.jupiter.api.Assertions.assertFalse;
  import static org.junit.jupiter.api.Assertions.assertNotNull;
  import static org.junit.jupiter.api.Assertions.assertNull;
  import static org.junit.jupiter.api.Assertions.assertTrue;
  
  import java.text.SimpleDateFormat;
  import java.time.Instant;
  import java.util.Calendar;
  import java.util.Locale;
  
  import org.apache.commons.net.ftp.FTPFile;
  import org.apache.commons.net.ftp.FTPFileEntryParser;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;
  
  /**
   */
  public abstract class AbstractFTPParseTest {
      // associate Calendar unit ints with a readable string
      // MUST be listed least significant first, as the routine needs to
      // find the previous - less significant - entry
      protected enum CalendarUnit {
          MILLISECOND(Calendar.MILLISECOND), SECOND(Calendar.SECOND), MINUTE(Calendar.MINUTE), HOUR_OF_DAY(Calendar.HOUR_OF_DAY),
          DAY_OF_MONTH(Calendar.DAY_OF_MONTH), MONTH(Calendar.MONTH), YEAR(Calendar.YEAR);
  
          final int unit;
  
          CalendarUnit(final int calUnit) {
              unit = calUnit;
          }
      }
  
      private FTPFileEntryParser parser;
  
      protected SimpleDateFormat df;
  
      /**
       * during processing you could hook here to do additional tests
       *
       * @param test raw entry
       * @param f    parsed entry
       */
      protected void doAdditionalBadTests(final String test, final FTPFile f) {
      }
  
      /**
       * during processing you could hook here to do additional tests
       *
       * @param test raw entry
       * @param f    parsed entry
       */
      protected void doAdditionalGoodTests(final String test, final FTPFile f) {
      }
  
      /**
       * Method getBadListing. Implementors must provide a listing that contains failures.
       *
       * @return String[]
       */
      protected abstract String[] getBadListing();
  
      /**
       * Method getGoodListing. Implementors must provide a listing that passes.
       *
       * @return String[]
       */
      protected abstract String[] getGoodListing();
  
      /**
       * Method getParser. Provide the parser to use for testing.
       *
       * @return FTPFileEntryParser
       */
      protected abstract FTPFileEntryParser getParser();
  
      /**
       * Check if FTPFile entry parsing failed; i.e. if entry is null or date is null.
       *
       * @param f FTPFile entry - may be null
       * @return null if f is null or the date is null
       */
     protected FTPFile nullFileOrNullDate(final FTPFile f) {
         if (f == null || f.getTimestamp() == null) {
             return null;
         }
         return f;
     }
 
     @BeforeEach
     protected void setUp() throws Exception {
         parser = getParser();
         df = new SimpleDateFormat("EEE MMM dd HH:mm:ss yyyy", Locale.US);
     }
 
     @Test
     void testBadListing() {
 
         final String[] badsamples = getBadListing();
         for (final String test : badsamples) {
 
             final FTPFile f = parser.parseFTPEntry(test);
             assertNull(nullFileOrNullDate(f), "Should have Failed to parse <" + test + ">");
 
             doAdditionalBadTests(test, f);
         }
     }
 
     // Force subclasses to test precision
     abstract void testDefaultPrecision();
 
     @Test
     void testGoodListing() {
 
         final String[] goodsamples = getGoodListing();
         for (final String test : goodsamples) {
 
             final FTPFile f = parser.parseFTPEntry(test);
             assertNotNull(f, "Failed to parse " + test);
 
             doAdditionalGoodTests(test, f);
         }
     }
 
     /**
      * Method testParseFieldsOnDirectory. Provide a test to show that fields on a directory entry are parsed correctly.
      *
      * @throws Exception on error
      */
     abstract void testParseFieldsOnDirectory() throws Exception;
 
     /**
      * Method testParseFieldsOnFile. Provide a test to show that fields on a file entry are parsed correctly.
      *
      * @throws Exception on error
      */
     abstract void testParseFieldsOnFile() throws Exception;
 
     protected void testPrecision(final String listEntry, final CalendarUnit expectedPrecision) {
         final FTPFile file = getParser().parseFTPEntry(listEntry);
         assertNotNull(file, "Could not parse " + listEntry);
         final Calendar stamp = file.getTimestamp();
         assertNotNull(stamp, "Failed to parse time in " + listEntry);
         final Instant instant = file.getTimestampInstant();
         assertNotNull(instant, "Failed to parse time in " + listEntry);
         final int ordinal = expectedPrecision.ordinal();
         final CalendarUnit[] values = CalendarUnit.values();
         // Check expected unit and all more significant ones are set
         // This is needed for FTPFile.toFormattedString() to work correctly
         for (int i = ordinal; i < values.length; i++) {
             final CalendarUnit unit = values[i];
             assertTrue(stamp.isSet(unit.unit), "Expected set " + unit + " in " + listEntry);
         }
         // Check previous entry (if any) is not set
         // This is also needed for FTPFile.toFormattedString() to work correctly
         if (ordinal > 0) {
             final CalendarUnit prevUnit = values[ordinal - 1];
             assertFalse(stamp.isSet(prevUnit.unit), "Expected not set " + prevUnit + " in " + listEntry);
         }
     }
 
     abstract void testRecentPrecision();
 }