package fr.ifremer.quadrige3.core.dao.system.rule;
   
   /*-
    * #%L
    * Quadrige3 Core :: Quadrige3 Client Core
    * %%
    * Copyright (C) 2017 Ifremer
    * %%
    * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   * 
   * This program 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 General Public License for more details.
   * 
   * You should have received a copy of the GNU Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  import fr.ifremer.quadrige3.core.dao.referential.UnitImpl;
  import fr.ifremer.quadrige3.core.dao.referential.pmfm.FractionImpl;
  import fr.ifremer.quadrige3.core.dao.referential.pmfm.MatrixImpl;
  import fr.ifremer.quadrige3.core.dao.referential.pmfm.MethodImpl;
  import fr.ifremer.quadrige3.core.dao.referential.pmfm.ParameterImpl;
  import fr.ifremer.quadrige3.core.dao.technical.Assert;
  import fr.ifremer.quadrige3.core.vo.system.rule.RulePmfmVO;
  import org.hibernate.SessionFactory;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.context.annotation.Lazy;
  import org.springframework.stereotype.Repository;
  
  import java.sql.Timestamp;
  import java.util.Collection;
  
  /**
   * @see RulePmfm
   */
  @Repository("rulePmfmDao")
  @Lazy
  public class RulePmfmDaoImpl
          extends RulePmfmDaoBase
  {
      /**
       * Constructor used by Spring
       */
      @Autowired
      public RulePmfmDaoImpl(SessionFactory sessionFactory) {
          super();
          setSessionFactory(sessionFactory);
      }
  
      /**
       * {@inheritDoc}
       */
      protected RulePmfmVO handleSave(RulePmfmVO source, Timestamp updateDt)
      {
          Assert.notNull(source);
          Assert.notNull(source.getRuleCd());
  
          // Load parent
          Rule parent = get(RuleImpl.class, source.getRuleCd());
  
          // Load entity
          RulePmfm entity = null;
          boolean isNew = false;
          if (source.getRulePmfmId() != null) {
              entity = get(source.getRulePmfmId());
          }
          if (entity == null) {
              entity = RulePmfm.Factory.newInstance();
              parent.addRulePmfms(entity);
              entity.setRule(parent);
              isNew = true;
          }
  
          // Check update_dt :
          // NOT NEED on a client database
  
          // Update update_dt
          // NOT NEED on a client database
  
          // VO -> Entity
          rulePmfmVOToEntity(source, entity, true);
  
          // Save entity
          if (isNew) {
              getSession().save(entity);
              // Affect new Id
              source.setRulePmfmId(entity.getRulePmfmId());
          } else {
              getSession().update(entity);
          }
  
          return source;
      }
 
     /**
      * {@inheritDoc}
      */
     protected void handleRemoveByIds(Collection<Integer> rulePmfmIds) {
         for (Integer rulePmfmId: rulePmfmIds) {
             remove(rulePmfmId);
         }
     }
 
     /**
      * {@inheritDoc}
      */
     public void toRulePmfmVO(
             RulePmfm source,
             RulePmfmVO target)
     {
         super.toRulePmfmVO(source, target);
 
         // Rule
         if (source.getRule() == null) {
             target.setRuleCd(null);
         }
         else {
             target.setRuleCd(source.getRule().getRuleCd());
         }
 
         // Parameter
         if (source.getParameter() == null) {
             target.setParCd(null);
         }
         else {
             target.setParCd(source.getParameter().getParCd());
         }
 
         // Matrix
         if (source.getMatrix() == null) {
             target.setMatrixId(null);
         }
         else {
             target.setMatrixId(source.getMatrix().getMatrixId());
         }
 
         // Fraction
         if (source.getFraction() == null) {
             target.setFractionId(null);
         }
         else {
             target.setFractionId(source.getFraction().getFractionId());
         }
 
         // Method
         if (source.getMethod() == null) {
             target.setMethodId(null);
         }
         else {
             target.setMethodId(source.getMethod().getMethodId());
         }
 
         // Unit
         if (source.getUnit() == null) {
             target.setUnitId(null);
         }
         else {
             target.setUnitId(source.getUnit().getUnitId());
         }
     }
 
 
     /**
      * Retrieves the entity object that is associated with the specified value object
      * from the object store. If no such entity object exists in the object store,
      * a new, blank entity is created
      */
     private RulePmfm loadRulePmfmFromRulePmfmVO(RulePmfmVO rulePmfmVO)
     {
         RulePmfm rulePmfm = null;
         if (rulePmfmVO.getRulePmfmId() != null) {
             rulePmfm = this.get(rulePmfmVO.getRulePmfmId());
         }
         if (rulePmfm == null) {
             rulePmfm = RulePmfm.Factory.newInstance();
         }
         return rulePmfm;
     }
 
     /**
      * {@inheritDoc}
      */
     public RulePmfm rulePmfmVOToEntity(RulePmfmVO rulePmfmVO)
     {
         RulePmfm entity = this.loadRulePmfmFromRulePmfmVO(rulePmfmVO);
         this.rulePmfmVOToEntity(rulePmfmVO, entity, true);
         return entity;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void rulePmfmVOToEntity(
             RulePmfmVO source,
             RulePmfm target,
             boolean copyIfNull)
     {
         super.rulePmfmVOToEntity(source, target, copyIfNull);
 
         // Id
         if (copyIfNull || source.getRulePmfmId() != null) {
             target.setRulePmfmId(source.getRulePmfmId());
         }
 
         // Rule
         if (copyIfNull || source.getRuleCd() != null) {
             if (source.getRuleCd() == null) {
                 target.setRule(null);
             }
             else {
                 target.setRule(load(RuleImpl.class, source.getRuleCd()));
             }
         }
 
         // Parameters
         if (copyIfNull || source.getParCd() != null) {
             if (source.getParCd() == null) {
                 target.setParameter(null);
             }
             else {
                 target.setParameter(load(ParameterImpl.class, source.getParCd()));
             }
         }
 
         // Matrix
         if (copyIfNull || source.getMatrixId() != null) {
             if (source.getMatrixId() == null) {
                 target.setMatrix(null);
             }
             else {
                 target.setMatrix(load(MatrixImpl.class, source.getMatrixId()));
             }
         }
 
         // Fraction
         if (copyIfNull || source.getFractionId() != null) {
             if (source.getFractionId() == null) {
                 target.setFraction(null);
             }
             else {
                 target.setFraction(load(FractionImpl.class, source.getFractionId()));
             }
         }
 
         // Method
         if (copyIfNull || source.getMethodId() != null) {
             if (source.getMethodId() == null) {
                 target.setMethod(null);
             }
             else {
                 target.setMethod(load(MethodImpl.class, source.getMethodId()));
             }
         }
 
         // Unit
         if (copyIfNull || source.getUnitId() != null) {
             if (source.getUnitId() == null) {
                 target.setUnit(null);
             }
             else {
                 target.setUnit(load(UnitImpl.class, source.getUnitId()));
             }
         }
     }
 }