/*
    * Copyright 2007 The International Moth Class Association (IMCA)
    *
    * Licensed 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
    *
    *     http://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 net.sf.imca.services;
  
  import java.io.UnsupportedEncodingException;
  import java.security.NoSuchAlgorithmException;
  
  import javax.mail.MessagingException;
  import javax.mail.internet.AddressException;
  import javax.mail.internet.InternetAddress;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import net.sf.imca.model.PersonBO;
  import net.sf.imca.model.entities.PersonEntity;
  import net.sf.imca.model.entities.AddressEntity;
  import net.sf.imca.model.exceptions.DataCheckingException;
  import net.sf.imca.model.exceptions.LogInException;
  import net.sf.imca.model.exceptions.RegistrationException;
  
  /**
   * Service for login, and register use cases.
   *
   * @author dougculnane
   */
  public class LoginRegisterService extends Service {
  
      /**
       * Apache Commons Logger specific to this class.
       */
      private Log log = LogFactory.getLog(LoginRegisterService.class);
  
      /**
       * Try to login the using the user supplied parameters.
       * 
       * @param email
       *            Users email address.
       * @param password
       *            User supplied password
       * @return the matching person.
       * @throws LogInException
       *             If there is an unsuccessful login.
       */
      public PersonBO login(String email, String password) throws LogInException {
  
          PersonBO person = null;
          try {
              startTransaction();
              person = new PersonBO(em, email, password);
              try {
                  this.endTransaction();
              } catch (Exception ex) {
                  log.error(ex);
                  throw new LogInException(ex.getMessage());
              }
              log.info("User " + email + " loged in.");
          } catch (LogInException lie) {
              log.warn(lie);
              try {
                  this.endTransaction();
              } catch (Exception ex) {
                  log.error(ex);
              }
              throw lie;
          }
          return person;
      }
  
      public PersonBO register(String email, String password,
              String confirmPassword, String countryCode, 
              String firstName, String lastName) 
              throws RegistrationException, DataCheckingException {
  
          if (email == null || password == null) {
              log.warn("Email or Password value is NULL");
              throw new RegistrationException("Email or Password value is NULL");
          }
          if (email.trim().length() == 0) {
              log.warn("Email value is empty.");
              throw new RegistrationException("Email value is empty");
          }
          if (!(email.indexOf("@") > 0)) {
              log.warn("Invalid email address: " + email);
              throw new RegistrationException("Email Address not valid.");
          }
         if (password.length() < 8) {
             log.warn("Password too short.");
             throw new RegistrationException("Password too short");
         }
         if (!confirmPassword.equals(password)) {
             log.warn("Password and confirm password are not the same.");
             throw new RegistrationException(
                     "Password and Confirm Password do not match");
         }
 
         try {
             new InternetAddress(email);
         } catch (AddressException e) {
             log.warn("Invalid email address: " + email, e);
             throw new RegistrationException("Email Address not valid.");
         }
         
         PersonBO person;
         try {
             startTransaction();
             person = new PersonBO();
             person.setEntity(new PersonEntity());
             person.getEntity().setEmail(email);
             person.setPasswordEncodeAndSet(password);
             person.getEntity().setFirstName(firstName);
             person.getEntity().setLastName(lastName);
             if (person.getEntity().getAddress() == null) {
                 person.getEntity().setAddress(new AddressEntity());
             }
             person.getEntity().getAddress().setCountryCode(countryCode);
             person.register(em);
             try {
                 this.endTransaction();
             } catch (Exception ex) {
                 log.error(ex);
                 throw new RegistrationException(ex.getMessage());
             }
         } catch (RegistrationException re) {
             log.warn(re);
             try {
                 this.endTransaction();
             } catch (Exception ex) {
                 log.error(ex);
                 throw new RegistrationException(ex.getMessage());
             }
             throw re;
         } catch (AddressException e) {
             log.warn("Invalid email address: " + email, e);
             throw new RegistrationException("Email Address not valid.");
         } catch (UnsupportedEncodingException e) {
             log.error(e);
             throw new RegistrationException("Error encoding password.");
         } catch (NoSuchAlgorithmException e) {
             log.error(e);
             throw new RegistrationException("Error encoding password.");
         }
         
         log.info("Registered new user: " + person.getName() 
                 + " (" + email+ ")." );
 
         return person;
     }
 
     /**
      * Send a new reset password to the supplied email address.
      * 
      * @param email
      *            email of user requesting password.
      * @return success
      * @throws MessagingException
      *             If there is a problem.
      */
     public boolean sendPassword(String email) throws MessagingException, DataCheckingException {
 
         InternetAddress intAdr = new InternetAddress(email);
 
         try {
             startTransaction();
 
             PersonBO person = new PersonBO(em, email);
             if (person.getEntity() == null) {
                 throw new DataCheckingException("Can not find email in database.");
             }
             person.sendPassword(em, intAdr);
             log.info("Password resent and sent to: " + email);
 
             try {
                 this.endTransaction();
             } catch (Exception ex) {
                 log.error(ex);
                 throw new DataCheckingException(ex.getMessage());
             }
         } catch (MessagingException me) {
             log.error(me);
             try {
                 this.endTransaction();
             } catch (Exception ex) {
                 log.error(ex);
                 throw new DataCheckingException(ex.getMessage());
             }
             throw me;
         }
         return true;
     }
 
 }