package au.gov.amsa.ihs.reader;
   
   import static com.google.common.base.Optional.absent;
   import static com.google.common.base.Optional.of;
   
   import java.io.File;
   import java.io.IOException;
   import java.io.InputStream;
   import java.util.Enumeration;
  import java.util.Map;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipFile;
  
  import org.joda.time.DateTime;
  
  import com.google.common.base.Optional;
  
  import au.gov.amsa.ihs.model.Ship;
  import rx.Observable;
  import rx.Observable.OnSubscribe;
  import rx.Subscriber;
  
  public class IhsReader {
  
      public Observable<Map<String, String>> from(InputStream is, String parentElementName) {
          return Observable.just(is).lift(new OperatorIhsReader(parentElementName));
      }
  
      public static Observable<Map<String, String>> fromZip(File file) {
          return shipDataFilesAsInputStreamFromZip(file).lift(new OperatorIhsReader("ShipData"));
      }
  
      public static Observable<Map<String, Map<String, String>>> fromZipAsMapByImo(File file) {
          return fromZip(file).toMap(map -> map.get(Key.LRIMOShipNo.name()));
      }
  
      public static Observable<Map<String, Map<String, String>>> fromZipAsMapByMmsi(File file) {
          return fromZip(file)
                  // only ships with an mmsi
                  .filter(map -> map.get(Key.MaritimeMobileServiceIdentityMMSINumber.name()) != null)
                  // as map
                  .toMap(map -> map.get(Key.MaritimeMobileServiceIdentityMMSINumber.name()));
      }
  
      private static Observable<InputStream> shipDataFilesAsInputStreamFromZip(final File file) {
          return Observable.create(new OnSubscribe<InputStream>() {
  
              @Override
              public void call(Subscriber<? super InputStream> subscriber) {
  
                  ZipFile zip = null;
                  try {
                      zip = new ZipFile(file);
                      Enumeration<? extends ZipEntry> en = zip.entries();
                      while (en.hasMoreElements() && !subscriber.isUnsubscribed()) {
                          ZipEntry entry = en.nextElement();
                          if (entry.getName().startsWith("ShipData")
                                  && entry.getName().endsWith(".xml")) {
                              InputStream is = zip.getInputStream(entry);
                              System.out.println(entry.getName());
                              subscriber.onNext(is);
                          }
                      }
                      subscriber.onCompleted();
                  } catch (Exception e) {
                      subscriber.onError(e);
                  } finally {
                      try {
                          if (zip != null)
                              zip.close();
                      } catch (IOException e) {
                          // don't care
                      }
                  }
              }
  
          });
      }
  
      public static Ship toShip(Map<String, String> values) {
          return new ShipCreator(values).buildShip();
      }
  
      private static class ShipCreator {
          private final Map<String, String> values;
  
          ShipCreator(Map<String, String> values) {
              this.values = values;
          }
  
          Ship buildShip() {
              return Ship.builder().classificationSocietyCode(value("ClassificationSocietyCode"))
                      .countryOfBuildCode(value("CountryOfBuildCode"))
                      .yearOfBuild(toYearOfBuild(value("DateOfBuild")))
                      .monthOfBuild(toMonthOfBuild(value("DateOfBuild"))).flagCode(value("FlagCode"))
                      .grossTonnage(toLong(value("GrossTonnage")))
                      .groupBeneficialOwnerCompanyCode(value("GroupBeneficialOwnerCompanyCode"))
                      .groupBeneficialOwnerCountryOfDomicileCode(
                              value("GroupBeneficialOwnerCountryofDomicileCode"))
                     .imo(value("LRIMOShipNo").get())
                     .mmsi(value("MaritimeMobileServiceIdentityMMSINumber"))
                     .type2(value("ShiptypeLevel2")).type3(value("ShiptypeLevel3"))
                     .type4(value("ShiptypeLevel4")).type5(value("ShiptypeLevel5"))
                     .deadweightTonnage(toFloat(value("FormulaDWT"))).statCode5(value("StatCode5"))
                     .lengthOverallMetres(toFloat(value("LengthOverallLOA")))
                     .breadthMetres(toFloat(value("Breadth")))
                     .displacementTonnage(toFloat(value("Displacement")))
                     .draughtMetres(toFloat(value("Draught"))).speedKnots(toFloat(value("Speed")))
                     .lastUpdateTime(toDateTime(value("LastUpdateDate"))).name(value("ShipName"))
                     .shipBuilderCompanyCode(value("ShipbuilderCompanyCode"))
                     // build it
                     .build();
         }
 
         private Optional<String> value(String name) {
             String val = values.get(name);
             if (val == null)
                 return absent();
             else if (val.trim().length() == 0)
                 return absent();
             else
                 return Optional.fromNullable(val.trim());
         }
 
     }
 
     private static Optional<DateTime> toDateTime(Optional<String> value) {
         if (!value.isPresent())
             return absent();
         else {
             try {
                 return of(DateTime.parse(value.get()));
             } catch (RuntimeException e) {
                 return absent();
             }
         }
     }
 
     private static Optional<Integer> toYearOfBuild(Optional<String> value) {
         if (!value.isPresent())
             return absent();
         else {
             try {
                 return of(Integer.parseInt(value.get().substring(0, 4)));
             } catch (RuntimeException e) {
                 return absent();
             }
         }
     }
 
     private static Optional<Integer> toMonthOfBuild(Optional<String> value) {
         if (!value.isPresent())
             return absent();
         else {
             int month = Integer.parseInt(value.get().substring(4, 6));
             if (month > 0)
                 return of(month);
             else
                 return absent();
         }
     }
 
     private static Optional<Long> toLong(Optional<String> value) {
         if (!value.isPresent())
             return Optional.absent();
         else {
             return Optional.of(Long.parseLong(value.get()));
         }
     }
 
     private static Optional<Float> toFloat(Optional<String> value) {
         if (!value.isPresent())
             return Optional.absent();
         else {
             return Optional.of(Float.parseFloat(value.get()));
         }
     }
 
 }