/*
    * 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 java.util.List;
  
  import javax.persistence.Query;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import net.sf.imca.model.PersonBO;
  import net.sf.imca.model.entities.AddressEntity;
  import net.sf.imca.model.entities.PersonEntity;
  import net.sf.imca.model.exceptions.DataCheckingException;
  
  /**
   * Service for CRUD operations by the Data Admin Servlet.
   *
   * @author dougculnane
   */
  public class EditDataService extends Service {
  
      /**
       * Apache Commons Logger specific to this class.
       */
      private Log log = LogFactory.getLog(EditDataService.class);
  
      public Object saveEntity(Object entityObject, String id) throws Exception {
          startTransaction();
         
          Object dbObject;
          if (id == null || "null".equals(id) || "".equals(id) || "0".equals(id)) {
              dbObject = ReflectionUtil.getObject(entityObject.getClass().getName());
          } else {
              long dbId = new Long(id).longValue();
              dbObject = em.find(entityObject.getClass(), dbId);
          }
          ReflectionUtil.replaceDBObject(dbObject, entityObject);
  
          em.persist(dbObject);
          log.info("Saved Entity: (" + dbObject.getClass().getName() + ") " 
                  + dbObject.toString());
  
          endTransaction();
          return dbObject;
      }
      
      public PersonBO saveMyData(PersonEntity personEntity, String password, String confirmPassword) 
          throws DataCheckingException {
  
          if (!confirmPassword.equals(password)) {
              throw new DataCheckingException("Password and Confirm Password do not match");
          }
  
          startTransaction();
          PersonBO person = new PersonBO(em, personEntity.getId());
          if (!"".equals(password)) {
              try {
                  person.setPasswordEncodeAndSet(password);
              } catch (UnsupportedEncodingException e) {
                  throw new DataCheckingException("Passwords encoding problem");
              } catch (NoSuchAlgorithmException e) {
                  throw new DataCheckingException("Passwords encoding problem");
              }
          }
          person.replaceEmail(em, personEntity.getEmail());
          person.getEntity().setFirstName(personEntity.getFirstName());
          person.getEntity().setLastName(personEntity.getLastName());
          person.getEntity().setTel(personEntity.getTel());
          person.getEntity().setMobile(personEntity.getMobile());
          person.getEntity().setClub(personEntity.getClub());
          person.getEntity().setLanguageCode(personEntity.getLanguageCode());
          if (person.getEntity().getAddress() == null) {
              person.getEntity().setAddress(new AddressEntity());
          }
          person.getEntity().getAddress().setStreet1(personEntity.getAddress().getStreet1());
          person.getEntity().getAddress().setStreet2(personEntity.getAddress().getStreet2());
          person.getEntity().getAddress().setArea(personEntity.getAddress().getArea());
          person.getEntity().getAddress().setPostCode(personEntity.getAddress().getPostCode());
          person.getEntity().getAddress().setCity(personEntity.getAddress().getCity());
          person.getEntity().getAddress().setCountryCode(personEntity.getAddress().getCountryCode());
          
          em.persist(person.getEntity().getAddress());
         em.persist(person.getEntity());
         log.info("Saved PersonEntity: " + person.getEntity().toString());
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return null;
         }
         return person;
     }
 
     @SuppressWarnings("unchecked")
     public Object findEntity(Class clazz, long goToId) {
         startTransaction();
         Object object = em.find(clazz, goToId);
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return null;
         }
         return object;
     }
 
     @SuppressWarnings("unchecked")
     public List search(String entityName, String search) {
         startTransaction();
         Query query = em.createNamedQuery(entityName + "BasicSearch");
         query.setParameter("search", "%" + search + "%");
         List list = query.getResultList();
         try {
             this.endTransaction();
         } catch (Exception ex) {
             log.error(ex);
             return null;
         }
         return list;
     }
 
     /**
      * Delete the Database entity object.
      * @param entityObject
      * @param id
      * @return
      * @throws Exception
      */
     public boolean deleteEntity(Object entityObject, String id) throws Exception {
 
         startTransaction();
         Object object = em.find(entityObject.getClass(), new Long(id).longValue());
         em.remove(object);
         endTransaction();
         log.info("Deleted object: " + object.toString());
         return true;
     }
 
 }