package fr.ifremer.quadrige3.core.dao.administration.strategy;
   
   /*-
    * #%L
    * Quadrige3 Core :: Quadrige3 Client Core
    * $Id:$
    * $HeadURL:$
    * %%
    * 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 com.google.common.collect.Maps;
  import fr.ifremer.quadrige3.core.dao.administration.program.Program;
  import fr.ifremer.quadrige3.core.dao.administration.program.ProgramImpl;
  import fr.ifremer.quadrige3.core.dao.administration.user.Department;
  import fr.ifremer.quadrige3.core.dao.administration.user.DepartmentImpl;
  import fr.ifremer.quadrige3.core.dao.administration.user.Quser;
  import fr.ifremer.quadrige3.core.dao.administration.user.QuserImpl;
  import fr.ifremer.quadrige3.core.dao.technical.Assert;
  import fr.ifremer.quadrige3.core.dao.technical.Beans;
  import fr.ifremer.quadrige3.core.dao.technical.Daos;
  import fr.ifremer.quadrige3.core.vo.administration.strategy.AppliedStrategyVO;
  import fr.ifremer.quadrige3.core.vo.administration.strategy.PmfmStrategyVO;
  import fr.ifremer.quadrige3.core.vo.administration.strategy.StrategyVO;
  import org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.collections4.MapUtils;
  import org.apache.commons.lang3.ArrayUtils;
  import org.hibernate.SessionFactory;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.context.annotation.Lazy;
  import org.springframework.stereotype.Repository;
  
  import javax.annotation.Resource;
  import java.sql.Timestamp;
  import java.util.Collection;
  import java.util.Map;
  import java.util.stream.Collectors;
  
  /**
   * <p>
   * StrategyDaoImpl class.
   * </p>
   *
   * @see Strategy
   */
  @Repository("strategyDao")
  @Lazy
  public class StrategyDaoImpl
          extends StrategyDaoBase {
  
      @Resource
      private AppliedStrategyDao appliedStrategyDao;
  
      @Resource
      private PmfmStrategyDao pmfmStrategyDao;
  
      /**
       * Constructor used by Spring
       *
       * @param sessionFactory a {@link org.hibernate.SessionFactory} object.
       */
      @Autowired
      public StrategyDaoImpl(SessionFactory sessionFactory) {
          super();
          setSessionFactory(sessionFactory);
      }
  
      /**
       * {@inheritDoc}
       */
      @Override
      public void remove(Collection<Strategy> entities) {
          Assert.notEmpty(entities);
  
          entities.forEach(this::remove);
      }
  
      /**
       * {@inheritDoc}
       */
      @Override
      public void remove(Integer stratId) {
          Strategy entity = get(stratId);
          remove(entity);
      }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void remove(Strategy entity) {
 
         // Remove applied strategies
         if (CollectionUtils.isNotEmpty(entity.getAppliedStrategies())) {
             // Check if these applied strategies can be removed
             appliedStrategyDao.checkCanRemove(entity.getAppliedStrategies().stream().map(AppliedStrategy::getAppliedStratId).collect(Collectors.toSet()));
             appliedStrategyDao.remove(entity.getAppliedStrategies());
             entity.getAppliedStrategies().clear();
         }
 
         getSession().flush();
 
         // Remove PmfmStrategies
         if (CollectionUtils.isNotEmpty(entity.getPmfmStrategies())) {
             pmfmStrategyDao.remove(entity.getPmfmStrategies());
             entity.getPmfmStrategies().clear();
         }
 
         getSession().flush();
 
         entity.getProgram().removeStrategies(entity);
         super.remove(entity);
     }
 
     /**
      * {@inheritDoc}
      */
     public void toStrategyVO(
             Strategy source,
             StrategyVO target) {
         // Copy basic attributes
         super.toStrategyVO(source, target);
 
         // Program
         if (source.getProgram() == null) {
             target.setProgCd(null);
         } else {
             target.setProgCd(source.getProgram().getProgCd());
         }
 
         // resp deps
         if (CollectionUtils.isEmpty(source.getDepartments())) {
             target.setRespDepIds(null);
         } else {
             target.setRespDepIds(source.getDepartments().stream().map(Department::getDepId).toArray(Integer[]::new));
         }
 
         // Resp qusers
         if (CollectionUtils.isEmpty(source.getQusers())) {
             target.setRespQuserIds(null);
         } else {
             target.setRespQuserIds(source.getQusers().stream().map(Quser::getQuserId).toArray(Integer[]::new));
         }
 
         // Applied strategies
         if (CollectionUtils.isEmpty(source.getAppliedStrategies())) {
             target.setAppliedStrategyVOs(null);
         } else {
             target.setAppliedStrategyVOs(appliedStrategyDao.toAppliedStrategyVOArray(source.getAppliedStrategies()));
         }
 
         // Pmfm strategies
         if (CollectionUtils.isEmpty(source.getPmfmStrategies())) {
             target.setPmfmStrategyVOs(null);
         } else {
             target.setPmfmStrategyVOs(pmfmStrategyDao.toPmfmStrategyVOArray(source.getPmfmStrategies()));
         }
 
     }
 
     /**
      * 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 Strategy loadStrategyFromStrategyVO(StrategyVO strategyVO) {
 
         Strategy strategy = null;
         if (strategyVO.getStratId() != null) {
             strategy = this.get(strategyVO.getStratId());
         }
         if (strategy == null) {
             strategy = Strategy.Factory.newInstance();
         }
         return strategy;
     }
 
     /**
      * {@inheritDoc}
      */
     public Strategy strategyVOToEntity(StrategyVO strategyVO) {
         Strategy entity = this.loadStrategyFromStrategyVO(strategyVO);
         this.strategyVOToEntity(strategyVO, entity, true);
         return entity;
     }
 
     /**
      * {@inheritDoc}
      */
     public void strategyVOToEntity(
             StrategyVO source,
             Strategy target,
             boolean copyIfNull) {
         super.strategyVOToEntity(source, target, copyIfNull);
 
         // Program
         if (copyIfNull || source.getProgCd() != null) {
             if (source.getProgCd() == null) {
                 target.setProgram(null);
             } else {
                 target.setProgram(load(ProgramImpl.class, source.getProgCd()));
             }
         }
 
         // Resp departments
         if (copyIfNull || ArrayUtils.isNotEmpty(source.getRespDepIds())) {
             if (ArrayUtils.isEmpty(source.getRespDepIds())) {
                 target.getDepartments().clear();
             } else {
                 Daos.replaceEntities(
                         target.getDepartments(),
                         source.getRespDepIds(),
                         depId -> load(DepartmentImpl.class, depId)
                 );
             }
         }
 
         // Resp qusers
         if (copyIfNull || ArrayUtils.isNotEmpty(source.getRespQuserIds())) {
             if (ArrayUtils.isEmpty(source.getRespQuserIds())) {
                 target.getQusers().clear();
             } else {
                 Daos.replaceEntities(
                         target.getQusers(),
                         source.getRespQuserIds(),
                         quserId -> load(QuserImpl.class, quserId)
                 );
             }
         }
     }
 
     /* -- Internal method -- */
 
     /**
      * {@inheritDoc}
      */
     @Override
     protected StrategyVO handleSave(StrategyVO source, Timestamp updateDt) {
         Assert.notNull(source);
         Assert.notNull(source.getProgCd());
 
         // Load parent
         Program parent = get(ProgramImpl.class, source.getProgCd());
 
         // Load entity
         Strategy entity = null;
         boolean isNew = false;
         if (source.getStratId() != null) {
             entity = get(source.getStratId());
         }
         if (entity == null) {
             entity = Strategy.Factory.newInstance();
             parent.addStrategies(entity);
             entity.setProgram(parent);
             entity.setStratId(source.getStratId()); // assigned id
             isNew = true;
         }
 
         // Check update_dt :
         // NOT NEED on a client database
 
         // Update update_dt
         // NOT NEED on a client database
 
         // VO -> Entity
         strategyVOToEntity(source, entity, true);
 
         // Save entity
         if (isNew) {
             Integer stratId = (Integer) getSession().save(entity);
             source.setStratId(stratId);
         } else {
             getSession().update(entity);
         }
 
         // Keep trace of items to remove
         Map<Integer, PmfmStrategy> pmfmStrategiesToRemove = Beans.mapByProperty(entity.getPmfmStrategies(), "pmfmStratId");
         Map<Integer, AppliedStrategy> appliedStrategiesToRemove = Beans.mapByProperty(entity.getAppliedStrategies(), "appliedStratId");
 
         // Save pmfm strategies
         Map<Integer, Integer> pmfmStratIdMapping = Maps.newHashMap();
         if (ArrayUtils.isNotEmpty(source.getPmfmStrategyVOs())) {
             for (PmfmStrategyVO pmfmStrategy : source.getPmfmStrategyVOs()) {
                 // Remember old applied strategy
                 Integer oldPmfmStratId = pmfmStrategy.getPmfmStratId();
 
                 // Update stratId (could have change)
                 pmfmStrategy.setStratId(entity.getStratId());
 
                 PmfmStrategyVO savedPmfmStrategy = pmfmStrategyDao.save(pmfmStrategy, updateDt);
 
                 if (oldPmfmStratId != null) {
                     pmfmStratIdMapping.put(oldPmfmStratId, savedPmfmStrategy.getPmfmStratId());
                 }
 
                 // Remove from items to remove
                 pmfmStrategiesToRemove.remove(savedPmfmStrategy.getPmfmStratId());
             }
         }
 
         // Save applied strategies
         if (ArrayUtils.isNotEmpty(source.getAppliedStrategyVOs())) {
             for (AppliedStrategyVO appliedStrategy : source.getAppliedStrategyVOs()) {
 
                 // Update stratId (could have change)
                 appliedStrategy.setStratId(entity.getStratId());
 
                 AppliedStrategyVO savedAppliedStrategyVO = appliedStrategyDao.save(appliedStrategy, pmfmStratIdMapping, updateDt);
 
                 // Remove from items to remove
                 appliedStrategiesToRemove.remove(savedAppliedStrategyVO.getAppliedStratId());
             }
         }
 
         // Remove unused pmfm strategies
         if (MapUtils.isNotEmpty(pmfmStrategiesToRemove)) {
             pmfmStrategyDao.remove(pmfmStrategiesToRemove.values());
             entity.getPmfmStrategies().removeAll(pmfmStrategiesToRemove.values());
         }
 
         // Remove unused applied strategies
         if (MapUtils.isNotEmpty(appliedStrategiesToRemove)) {
             appliedStrategyDao.checkCanRemove(appliedStrategiesToRemove.keySet());
             appliedStrategyDao.remove(appliedStrategiesToRemove.values());
             entity.getAppliedStrategies().removeAll(appliedStrategiesToRemove.values());
         }
 
         return source;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     protected void handleRemoveByIds(Collection<Integer> stratIds) {
         Assert.notEmpty(stratIds);
 
         stratIds.forEach(this::remove);
     }
 
 }