package org.wcb.resources;
   
   import org.wcb.model.vo.LogImportVO;
   import org.wcb.model.vo.hibernate.Logbook;
   import org.wcb.exception.ServiceException;
   
   import java.io.Reader;
   import java.io.IOException;
   import java.util.Date;
  import java.util.List;
  import java.util.ArrayList;
  import java.text.SimpleDateFormat;
  import java.text.ParseException;
  
  import com.Ostermiller.util.CSVParser;
  
  /**
   * <small>
   * <p/>
   * Copyright (C)  2006  wbogaardt.
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   * <p/>
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   * <p/>
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
   * <p/>
   * $File:  $ <br>
   * $Change:  $ submitted by $Author: wbogaardt $ at $DateTime: Dec 7, 2006 8:22:57 AM $ <br>
   * </small>
   *
   * @author wbogaardt
   *         
   */
  public class ImportLogbookDataFile {
  
      public List<Logbook> process(Reader sValue, LogImportVO vo) throws IOException, ServiceException {
          String[][] result = CSVParser.parse(sValue, ',');
          return this.marshall(result, vo);
      }
  
      private List<Logbook> marshall(String[][] result, LogImportVO vo) throws ServiceException {
          String[] lineItem;
          List<Logbook> logbookEntries = new ArrayList<Logbook>();
          for (int i = 0; i < result.length; i++) {
              lineItem = result[i];
              if (lineItem.length >= vo.getLength()) {
                  logbookEntries.add(processLine(lineItem, vo));
              }
              else {
                  throw new ServiceException("Line " + i + " could not be processed!");
              }
          }
          return logbookEntries;
      }
  
      private Logbook processLine(String[] line, LogImportVO vo) throws ServiceException {
          Logbook lineItem = new Logbook();
          if (!isNegative(vo.getEntryDatePosition())) {
              lineItem.setEntryDate(parseDate(line[vo.getEntryDatePosition()]));
          }
          if (!isNegative(vo.getRegistrationPosition())) {
              lineItem.setRegistration(line[vo.getRegistrationPosition()]);
          }
          if (!isNegative(vo.getFAAFromPosition())) {
              lineItem.setFaaFrom(line[vo.getFAAFromPosition()]);
          }
          if (!isNegative(vo.getViaPosition())) {
              lineItem.setFaaVia(line[vo.getViaPosition()]);
          }
          if (!isNegative(vo.getFAAToPosition())) {
              lineItem.setFaaTo(line[vo.getFAAToPosition()]);
          }
          if (!isNegative(vo.getFlightDurationPosition())) {
              lineItem.setFlightDuration(parseDouble(line[vo.getFlightDurationPosition()]));
          }
          if (!isNegative(vo.getPICPosition())) {
              lineItem.setPic(parseDouble(line[vo.getPICPosition()]));
          }
          if (!isNegative(vo.getSICPosition())) {
              lineItem.setSic(parseDouble(line[vo.getSICPosition()]));
          }
          if (!isNegative(vo.getFlightInstructingPosition())) {
              lineItem.setFlightInstructing(parseDouble(line[vo.getFlightInstructingPosition()]));
          }
          if (!isNegative(vo.getCrossCountryPosition())) {
              lineItem.setCrossCountry(parseDouble(line[vo.getCrossCountryPosition()]));
          }
          if (!isNegative(vo.getSafetyPilotPosition())) {
              lineItem.setSafetyPilot(parseDouble(line[vo.getSafetyPilotPosition()]));
          }
          if (!isNegative(vo.getDualReceivedPosition())) {
             lineItem.setDualReceived(parseDouble(line[vo.getDualReceivedPosition()]));
         }
         if (!isNegative(vo.getSoloPosition())) {
             lineItem.setSolo(parseDouble(line[vo.getSoloPosition()]));
         }
         if (!isNegative(vo.getDayTakoffPosition())) {
             lineItem.setDayTakeoffs(parseInteger(line[vo.getDayTakoffPosition()]));
         }
         if (!isNegative(vo.getDayLandingPosition())) {
             lineItem.setDayLandings(parseInteger(line[vo.getDayLandingPosition()]));
         }
         if (!isNegative(vo.getNightTakeoffPosition())) {
             lineItem.setNightTakeoffs(parseInteger(line[vo.getNightTakeoffPosition()]));
         }
         if (!isNegative(vo.getNightLandingPosition())) {
             lineItem.setNightLandings(parseInteger(line[vo.getNightLandingPosition()]));
         }
         if (!isNegative(vo.getInstrumentApproachesPosition())) {
             lineItem.setInstrumentApproaches(parseInteger(line[vo.getInstrumentApproachesPosition()]));
         }
         if (!isNegative(vo.getConditionNightPosition())) {
             lineItem.setConditionNight(parseDouble(line[vo.getConditionNightPosition()]));
         }
         if (!isNegative(vo.getActualIMCPosition())) {
             lineItem.setConditionActualImc(parseDouble(line[vo.getActualIMCPosition()]));
         }
         if (!isNegative(vo.getSimulatedIMCPosition())) {
             lineItem.setConditionSimulatedImc(parseDouble(line[vo.getSimulatedIMCPosition()]));
         }
         if (!isNegative(vo.getFlightSimPosition())) {
             lineItem.setConditionFlightSim(parseDouble(line[vo.getFlightSimPosition()]));
         }
         //service.saveLogBookEntry(lineItem);
         return lineItem;
     }
 
     private boolean isNegative(int value) {
         return value < 0;
     }
 
     private Integer parseInteger(String sVal) {
         try
         {
             return Integer.parseInt(sVal);
         }
         catch (NumberFormatException nfe) {
             return 0;
         }
     }
 
     private Double parseDouble(String sVal) {
         try
         {
             return Double.parseDouble(sVal);
         }
         catch (NumberFormatException nfe) {
             return 0.0;
         }
 
     }
 
     private Date parseDate(String sValue) {
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-M-dd");
         try {
             return sdf.parse(sValue);
         }
         catch (ParseException pse) {
             return new Date();
         }
     }
 }