package org.jleaf.erp.sls.bo.salesman;

import java.util.List;

import javax.persistence.Query;

import org.jleaf.common.entity.User;
import org.jleaf.core.AbstractBusinessFunction;
import org.jleaf.core.BusinessFunction;
import org.jleaf.core.Dto;
import org.jleaf.core.GeneralConstants;
import org.jleaf.core.annotation.Info;
import org.jleaf.core.annotation.InfoIn;
import org.jleaf.core.annotation.InfoOut;
import org.jleaf.core.dao.CriteriaHelper;
import org.jleaf.core.dao.QueryBuilder;
import org.jleaf.erp.master.bo.partner.FindPartnerByIndex;
import org.jleaf.erp.master.dao.PartnerDao;
import org.jleaf.erp.master.entity.Partner;
import org.jleaf.erp.master.entity.PartnerAddress;
import org.jleaf.erp.master.entity.PartnerCp;
import org.jleaf.erp.master.entity.PartnerType;
import org.jleaf.erp.sls.SalesConstants;
import org.jleaf.erp.sls.dao.SalesmanVisitPlanDao;
import org.jleaf.erp.sls.entity.Order;
import org.jleaf.erp.sls.entity.PolicyCustomerGroupBrand;
import org.jleaf.erp.sls.entity.SalesmanDate;
import org.jleaf.erp.sls.entity.SalesmanVisitPlan;
import org.jleaf.erp.sls.entity.So;
import org.jleaf.erp.sls.entity.UserPartner;
import org.jleaf.util.DateUtil;
import org.jleaf.util.DtoUtil;
import org.jleaf.util.ValidationUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 *
 * @author Ephraim Jehudah, April 09, 2020
 *
 **/

//@formatter:off
@Service
@InfoIn(value = {
    @Info(name = "userLoginId", description = "user Login Id", type = Long.class),
    @Info(name = "tenantLoginId", description = "tenant Login Id", type = Long.class),
    @Info(name = "roleLoginId", description = "roleLoginId", type = Long.class),
    @Info(name = "datetime", description = "datetime", type = String.class),
    @Info(name = "apiKey", description = "apiKey", type = String.class),
    @Info(name = "salesmanId", description = "salesman Id", type = Long.class),
    @Info(name = "date", description = "date", type = String.class),
})
@InfoOut(value = {
    @Info(name = "salesmanVisitSummary", description = "salesmanVisitSummary {targetCall, realCall, callLeft, daysLeft, omzetRealization}", type = Object.class)
})
//@formatter:on
public class GetTodaySalesmanVisitSummaryBySalesman extends AbstractBusinessFunction implements BusinessFunction {
    private static final Logger log = LoggerFactory.getLogger(GetTodaySalesmanVisitSummaryBySalesman.class);

    @Autowired
    PartnerDao partnerDao;

    @Autowired
    SalesmanVisitPlanDao salesmanVisitPlanDao;

    @Override
    public String getDescription() {
        return "Get Today Salesman Visit Summary By Salesman";
    }

    @SuppressWarnings("unchecked")
    @Override
    public Dto execute(Dto inputDto) throws Exception {
        log.info("Input YANG MASUK BF {} -. {} ", inputDto);

        ValidationUtil.valDtoContainsKey(inputDto, "userLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "tenantLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "roleLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "datetime");
        ValidationUtil.valDtoContainsKey(inputDto, "salesmanId");
        ValidationUtil.valDtoContainsKey(inputDto, "date");

        Long userLoginId = inputDto.getLong("userLoginId");
        Long tenantLoginId = inputDto.getLong("tenantLoginId");
        Long roleLoginId = inputDto.getLong("roleLoginId");
        String datetime = inputDto.getString("datetime");
        String date = inputDto.getString("date").substring(0,8);
        String yearMonthDate = date.substring(0,6);
        String yearMonth = date.substring(0,6).concat("%");
        Long salesmanId = inputDto.getLong("salesmanId");

        Dto outputDto = new Dto();
        Object resultObject = null;
        Dto outputSummary = new Dto();

        Long realCall = new Long(0);
        Long targetCall = new Long(0);
        Long callLeft = new Long(0);
        Long daysLeft = new Long(0);
        Double omzetRealization = new Double(0);

      //realCall
      QueryBuilder realCallBuilder = new QueryBuilder();
      realCallBuilder.add("SELECT COALESCE(COUNT(1), 0) AS real_call")
      .add(" FROM ").add(SalesmanVisitPlan.TABLE_NAME)
      .add(" WHERE salesman_id = :salesmanId AND active = 'Y'")
      .add(" AND status_visit = 'Y' AND visit_date LIKE :yearMonth");
      log.info("Query realCall BF {} --> {} " , this.getClass(), realCallBuilder.toString());

      Query realCallQuery = salesmanVisitPlanDao.createNativeQuery(realCallBuilder.toString());
      realCallQuery.setParameter("salesmanId",salesmanId);
      realCallQuery.setParameter("yearMonth",yearMonth);

      resultObject = realCallQuery.getSingleResult();
      if(resultObject != null) {
         realCall = Long.valueOf(resultObject.toString());
      }
        outputSummary.put("realCall", realCall);


      //targetCall
      QueryBuilder targetCallBuilder = new QueryBuilder();
      targetCallBuilder.add("SELECT COALESCE(COUNT(1), 0) AS target_call")
      .add(" FROM ").add(SalesmanVisitPlan.TABLE_NAME)
      .add(" WHERE salesman_id = :salesmanId AND active = 'Y'")
      .add(" AND status_visit <> 'C' AND visit_date LIKE :yearMonth");
      log.info("Query BF targetCallBuilder {} --> {} " , this.getClass(), targetCallBuilder.toString());

      Query targetCallQuery = salesmanVisitPlanDao.createNativeQuery(targetCallBuilder.toString());
      targetCallQuery.setParameter("salesmanId",salesmanId);
      targetCallQuery.setParameter("yearMonth",yearMonth);

      resultObject = targetCallQuery.getSingleResult();
      if(resultObject != null) {
          targetCall = Long.valueOf(resultObject.toString());
      }
      outputSummary.put("targetCall", targetCall);

      //callLeft
      QueryBuilder callLeftBuilder = new QueryBuilder();
      callLeftBuilder.add("SELECT COALESCE(COUNT(1), 0) AS call_left")
      .add(" FROM ").add(SalesmanVisitPlan.TABLE_NAME)
      .add(" WHERE salesman_id = :salesmanId AND active = 'Y'")
      .add(" AND status_visit <> 'C' AND status_visit <> 'Y' AND visit_date LIKE :yearMonth")
      .add(" AND visit_date >= :visitDate");
      log.info("Query BF callLeftBuilder {} --> {} " , this.getClass(), callLeftBuilder.toString());

      Query callLeftQuery = salesmanVisitPlanDao.createNativeQuery(callLeftBuilder.toString());
      callLeftQuery.setParameter("salesmanId",salesmanId);
      callLeftQuery.setParameter("yearMonth",yearMonth);
      callLeftQuery.setParameter("visitDate",date);

      resultObject = targetCallQuery.getSingleResult();
      if(resultObject != null) {
          callLeft = Long.valueOf(resultObject.toString());
      }
      outputSummary.put("callLeft", callLeft);

      //daysLeft
      if(date != "") {
      String dateEnd =DateUtil.getEndOfMonth(yearMonthDate);
      daysLeft = Long.valueOf(dateEnd.substring(6)) - Long.valueOf(yearMonthDate);
      }
      outputSummary.put("daysLeft", daysLeft);

      //omzetRealization
      QueryBuilder omzetRealizationBuilder = new QueryBuilder();
      omzetRealizationBuilder.add("SELECT COALESCE(SUM(B.gross_sell_price), 0) AS omzetRealization")
      .add(" FROM ").add(So.TABLE_NAME).add(" A ")
      .add(" INNER JOIN sl_so_item B ON A.so_id = B.so_id")
      .add(" WHERE A.salesman_id =:salesmanId AND A.tenant_id =:tenantId")
      .add(" AND A.doc_date LIKE :yearMonth");
      log.info("Query BF omzetRealizationBuilder {} --> {} " , this.getClass(), omzetRealizationBuilder.toString());

      Query omzetRealizationQuery = salesmanVisitPlanDao.createNativeQuery(omzetRealizationBuilder.toString());
      omzetRealizationQuery.setParameter("salesmanId",salesmanId);
      omzetRealizationQuery.setParameter("tenantId",tenantLoginId);
      omzetRealizationQuery.setParameter("yearMonth",yearMonth);

      resultObject = targetCallQuery.getSingleResult();
      if(resultObject != null) {
          omzetRealization = Double.valueOf(resultObject.toString());
      }
      outputSummary.put("omzetRealization", omzetRealization);


        //all result
        outputDto.put("salesmanVisitSummary", outputSummary);
        log.debug("Output BF {} -. {} ", this.getClass(), outputDto);

        return outputDto;
    }

}