package org.wcb.model.bd;
   
   import org.wcb.model.service.ILogbookService;
   import org.wcb.model.service.IServicesConstants;
   import org.wcb.model.service.IValidatorService;
   import org.wcb.model.vo.hibernate.Logbook;
   import org.wcb.model.vo.hibernate.AircraftBO;
   import org.wcb.model.vo.hibernate.AircraftTypeBO;
   import org.wcb.model.util.SpringUtil;
  import org.wcb.exception.ServiceException;
  
  import javax.swing.*;
  import java.util.List;
  import java.util.ArrayList;
  
  /**
   * <small>
   * Copyright (c)  2006  wbogaardt.
   * Permission is granted to copy, distribute and/or modify this document
   * under the terms of the GNU Free Documentation License, Version 1.2
   * or any later version published by the Free Software Foundation;
   * with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
   * Texts.  A copy of the license is included in the section entitled "GNU
   * Free Documentation License".
   * <p/>
   * $File:  $ <br>
   * $Change:  $ submitted by $Author: wbogaardt $ at $DateTime: Mar 24, 2006 1:17:29 PM $ <br>
   * </small>
   *
   * @author wbogaardt
   * @version 1
   *          Date: Mar 24, 2006
   *          Time: 1:17:29 PM
   */
  
  public class LogbookDelegate {
  
      private ILogbookService logbookService;
      private IValidatorService logbookValidator;
  
      public ILogbookService getLogbookService() {
          if(logbookService == null)
          {
              logbookService = (ILogbookService) SpringUtil.getApplicationContext().getBean(IServicesConstants.LOGBOOK_SERVICE);
          }
          return logbookService;
      }
  
      public void setLogbookService(ILogbookService logbookService) {
          this.logbookService = logbookService;
      }
  
      public IValidatorService getValidatorService() {
          if( logbookValidator == null) {
              logbookValidator = (IValidatorService) SpringUtil.getApplicationContext().getBean(IServicesConstants.LOGBOOK_VALIDATION_SERVICE);
          }
          return logbookValidator;
      }
  
      public void setValidatorService(IValidatorService svc) {
          logbookValidator = svc;
      }
  
      /**
       * This takes a log book entry and uses the LogbookValidatorService
       * to validate that all data required and is entered correctly.
       * This should be run before saving the data to the database. It can also
       * be used to validate information back to the user.
       * @param entry Logbook entry to validate
       * @return True everything is correct based on business rules otherwise it returns false.
       */
      public boolean validate(Logbook entry) {
          IValidatorService validator = getValidatorService();
          validator.setObject(entry);
          return validator.validate();
      }
  
      /**
       * This gives access to save a log book entry or even updated an existing one
       * due to the underlying hibernate framework.
       * @param entry The log book entry.
       */
      public void saveLogEntry(Logbook entry) {
          try
          {
              getLogbookService().saveLogBookEntry(entry);
          }
          catch (ServiceException se)
          {
              se.printStackTrace();
          }
      }
  
      /**
       * Gets a list of all the logbook entries in the database.
       * @return List of Logbook wrapped data objects.
       */
      public List<Logbook> getAllLogbookEntries() {
          try
         {
             return getLogbookService().getAllLogbookEntries();
         }
         catch (ServiceException se)
         {
             if(se.getCause().getMessage().equals("No access to database")) {
                int answer = JOptionPane.showConfirmDialog(null, "There appears to be more than one  \n" +
                         "instance of this application running.  \n" +
                         "Press ok to cancel running a multiple instance.", "Multiple Application Error", JOptionPane.DEFAULT_OPTION);
                 if(answer == JOptionPane.YES_OPTION) {
                     System.exit(0);
                 }
             }
             Logbook value = new Logbook();
             List<Logbook> returnVal = new ArrayList<Logbook>();
             returnVal.add(value);
             return returnVal;
         }
 
     }
 
      /**
      * Gets a list of all the logbook entries in the database.
      * @return List of Logbook wrapped data objects.
      */
     public List<Logbook> findByRegistration(String registration) {
         try
         {
             return getLogbookService().findByRegistration(registration);
         }
         catch (ServiceException se)
         {
             se.printStackTrace();
         }
         return null;
     }
 
     public boolean isAirplaneInLogbook(String registration) {
         List<Logbook> log = this.findByRegistration(registration);
         return log != null && log.size() > 0;
     }
 
     /**
      * Allows finding a log book entry based on the entry's primary key
      * @param pkId  The primary key to look up the entry on.
      * @return  The row data of the logbook entry
      */
     public Logbook findLogEntry(Integer pkId) {
         try
         {
             return getLogbookService().findLogBookEntry(pkId);
         }
         catch (ServiceException se)
         {
             se.printStackTrace();
         }
         return null;
     }
 
     /**
      * Deletes a logbook entry
      * @param entry The entry to delete
      */
     public boolean deleteLogEntry(Logbook entry) {
         try
         {
             getLogbookService().deleteLogBookEntry(entry);
         }
         catch (ServiceException se)
         {
             se.printStackTrace();
             return false;
         }
         return true;
     }
 
     public AircraftBO getAircraftForLogEntry(Logbook lineitem) {
         AircraftBO returnValue = new AircraftBO();
         try
         {
             String registry = lineitem.getRegistration();
             returnValue.setRegistrationNumber(registry);
             return getLogbookService().getAircraftByRegistration(registry);
         }
         catch (ServiceException se)
         {
             //should log the exception but will return a default airplane with the requested registration number.
             returnValue = new AircraftBO(lineitem.getRegistration(), 1);
         }
         return returnValue;
     }
 
     public AircraftTypeBO getAircraftType(AircraftBO aircraft) {
         try
         {
             return getLogbookService().getAircraftTypeById(aircraft.getTypeId());
         }
         catch (ServiceException se)
         {
             return new AircraftTypeBO("Cessna", "150M", "C-150M",1);
         }
     }
 }