<?php

class Sinistro2_Model_CronometroRegulacao extends Agro_Db_Table_Abstract {
	protected $_schema = 'sinistro';
    protected $_name = 'cronometro_regulacao';
    protected $_primary = 'id';
    public const CRIADO = 0;
    public const ATIVO = 0;
    public const SUSPENSO = 0;
    public const FINALIZADO = 0;
    public const PARADO = 0;

    private array $statusIds = [];

    public function __construct()
    {
        $modelStatus = new Sistema_Model_Status();
        $nomes = ['CRIADO', 'ATIVO', 'SUSPENSO', 'FINALIZADO', 'PARADO'];

        foreach ($nomes as $nome) {
            $this->statusIds[$nome] = $modelStatus->getId($nome, 'CONTADOR_REGULACAO');
        }
        parent::__construct();
    }
        
    public function save($data)
    {
        try{

    		$Row = $this->getRow($data['id_cronometro']);
      
    		$novoCronometro = false;
    		if(!$Row->id) {
                $novoCronometro = true;               
                $Row = $this->createRow();
    		}

		    $Row->id_proposta           = $data['id_proposta'];
		    $Row->id_aviso_encerramento = $data['id_aviso'];
            $Row->id_status             = $data['id_status'];
            $Row->dt_inicio             = $data['dt_inicio'] ? $data['dt_inicio'] : null;

		    $idCronometro = $Row->save();
            if($novoCronometro){
                $dataLog = [
			        'id_status_atual' => $data['id_status'],
			        'ds_observacao' => "Contagem iniciada",
			        'id_cronometro' => $idCronometro 
		        ];
                $this->setLog($dataLog);
            }
            return $idCronometro;
        }catch(Exception $e){
            $this->setMessage($e->getMessage());
            return false;
        }
    }

    public static function all(): array
    {
        return [
            self::CRIADO,
            self::ATIVO,
            self::SUSPENSO,
            self::FINALIZADO,
            self::PARADO,
        ];
    }

    public function atualizarStatus($idCronometro, $id_status, $ds_observacao = false, $retomada = false)
    {
        $Util           = new Agro_Util();
        $User           = Zend_Auth::getInstance()->getIdentity();
        $modelStatus    = new Sistema_Model_Status();
        try{
            $Row = $this->getRow($idCronometro);
            
            $id_status_antiga = $Row->id_status;
            
            if (!$Row) {
                throw new RuntimeException("Cronômetro não encontrado");
            }
            if($Row->id_status == $id_status){
                return false;
            }
       
            $Row->id_status = $id_status;

            switch($id_status){
                case $this->statusIds['ATIVO']:
                    if($id_status_antiga == $modelStatus->getId("SUSPENSO", 'CONTADOR_REGULACAO') && !$retomada){
                        return false;
                    }
                    $log                    = "[Contador iniciado] ";
                    if(!$Row->dt_suspenso){
                        $Row->dt_suspenso = date('Y-m-d');
                    }
                    $nr_dias_suspenso       = $this->calculaIntervalo($Row->dt_suspenso);
                    $Row->nr_dias_suspenso  = $Row->nr_dias_suspenso + $nr_dias_suspenso;
                    $Row->dt_inicio         = $Util->proximoDiaUtil()->format('Y-m-d');
                    $Row->dt_suspenso       = null;
                break;
                case $this->statusIds['SUSPENSO']:
                    if($id_status_antiga == $modelStatus->getId("PARADO", 'CONTADOR_REGULACAO')){
                        return false;
                    }
                    $log                    = "[Contador interrompido] ";
                    
                    if(!$Row->dt_inicio){
                        $Row->dt_inicio = date('Y-m-d');
                    }
                    $nr_dias_ativo          = $this->calculaIntervalo($Row->dt_inicio);
                    $Row->nr_dias_ativo     = $Row->nr_dias_ativo + $nr_dias_ativo;
                    $Row->dt_suspenso       = date('Y-m-d');
                    $Row->dt_inicio         = null;
                break;
                case $this->statusIds['PARADO']: //zerar
                    if($id_status_antiga == $modelStatus->getId("SUSPENSO", 'CONTADOR_REGULACAO')){
                        return false;
                    }
                    $log = "[Contador interrompido] ";
                    
                    $Row->nr_dias_regulado  = 0;
                    $Row->nr_dias_suspenso  = 0;
                    $Row->nr_dias_ativo     = 0;

                    $Row->dt_inicio = null;
                    $Row->dt_suspenso = null;
                    if(!$ds_observacao){ //quer dizer que ta zerando no contexto de exclusão de aviso
                        $ds_observacao = 'Zerado devido exclusão de aviso de encerramento de colheita';
                    }
                break;
                case $this->statusIds['FINALIZADO']:
                    $log = "[Contador finalizado] ";
                    //"Finalizar" = alterar: dt_inicio, dt_fim, id_status, nr_dias_regulado
                    $dt_fim                 = new DateTime();
                    $dt_inicio              = new DateTime($Row->dt_inicio);
                    
                    $dados = [
                        'dt_inicio'         => $dt_inicio, 
                        'dt_fim'            =>  $dt_fim,
                        'nr_dias_suspenso'  => $Row->nr_dias_suspenso,
                        'nr_dias_ativo'     => $Row->nr_dias_ativo,
                        'id_status'         => $id_status_antiga
                    ];
                    
                    $nr_dias_regulado = $this->calcularDiasRegulacaoValida($dados);
                
                    $Row->dt_inicio         = null;
                    $Row->dt_fim            = $dt_fim->format('Y-m-d');
                    $Row->nr_dias_regulado  = $nr_dias_regulado;
                    $Row->id_status         = $id_status;
                    $Row->fl_ativo          = 'f';
                    $Row->fl_del            = 't';

                default:
                break;
            }

            $Row->dt_alteracao = date('Y-m-d H:i:s');
            $Row->save();

		    $this->setLog([
			    'id_status_antigo' => $id_status_antiga,
			    'id_status_atual' => $id_status,
			    'id_usuario_criacao' => $User->id,
			    'ds_observacao' => ($ds_observacao) ? $log.$ds_observacao : $log,
			    'id_cronometro' => $idCronometro
		    ]);
            return array('id_antiga'=>$id_status_antiga, 'id_nova'=>$id_status);
        }catch(Exception $e){
            return false;
        }
    }

    public function getByProposta($id_proposta, $id_aviso_encerramento = false) {
		$Select = $this->select()->setIntegrityCheck(false);
		$Select->where("id_proposta = ?", $id_proposta);
      
        if($id_aviso_encerramento){
            $Select->where("id_aviso_encerramento = ?", $id_aviso_encerramento);
        }
		return $this->_db->fetchAll($Select);
	}

    public function getCronometrosByProposta($id_proposta)
    {
		return $this->fetchAll($this->select()
				->setIntegrityCheck(false)
				->where('id_proposta IN (?)', $id_proposta)
            );
    }

    public function getCronometroByAvisoId($avisoId, $fl_ativo = true)
    {
        $fl_ativo = ($fl_ativo) ? $fl_ativo : 't';
		$rs = $this->fetchRow(
			$this->select()
				->setIntegrityCheck(false)
                ->from(array('cr'=>'sinistro.cronometro_regulacao'),'*')
                ->join(array('st'=>'sistema.status'), 'st.id = cr.id_status', 'ds_chave as ds_status')
				->where('cr.id_aviso_encerramento IN (?)', $avisoId)

		);

        if(!$rs){
            return false;
        }

        $rs = $rs->toArray();
        switch($rs['ds_status']){
            case 'SUSPENSO':
                $rs['ds_classe_status'] = 'status-danger';
                break;
            case 'ATIVO' || 'FINALIZADO':
                $rs['ds_classe_status'] = 'status-success';
                break;
            default:
            break;
        }

        return $rs;
    }

    public function getComboStatus()
    {
        $Select = $this->select()->setIntegrityCheck(false);
        $Select->from(array('ss'=>'sistema.status'), array('id', 'ds_chave'));
        $Select->where('ds_status LIKE ?', "CRONOMETRO%");
        return $this->_db->fetchAll($Select);
    }

    public function setLog($data)
	{
		$modelHistorico = new Sinistro2_Model_CronometroRegulacaoHistorico();
		$modelHistorico->save($data);
	}

    public function ativar($idCronometro){
        $modelStatus = new Sistema_Model_Status();
        return $this->atualizarStatus($idCronometro, $modelStatus->getId("ATIVO", 'CONTADOR_REGULACAO'));
    }

    public function reativar($cronometro)
    {
        $modelStatus        = new Sistema_Model_Status();
        if($cronometro['id_status'] == $modelStatus->getId("SUSPENSO", 'CONTADOR_REGULACAO')){     
        return true;}
        if($cronometro['id_status'] == $modelStatus->getId("ATIVO", 'CONTADOR_REGULACAO')){return true;}
      
        $dadosCronometro    = array(
			'id_cronometro' => $cronometro['id'],
			'id_status'		=> $modelStatus->getId("ATIVO", 'CONTADOR_REGULACAO'),
            'dt_inicio'     => date('Y-m-d'),
            'id_proposta'   => $cronometro['id_proposta'],
            'id_aviso'      => $cronometro['id_aviso_encerramento'],
            'dt_suspenso'   => null
		);
        
        $modelProcessos         = new Sinistro2_Model_Processos();
        $modelCronometro        = new Sinistro2_Model_CronometroRegulacao();
        $modelBeneficiarios     = new Seguro_Model_PropostasBeneficiarios();
        $modelAvisosEncerramento = new Sinistro2_Model_AvisosEncerramento();
        
        $doc_segurado       = $modelProcessos->isDocumentacaoSeguradoValida($cronometro['id_proposta']);
        $doc_beneficiarios  = $modelProcessos->isDocumentacaoBeneficiariosValida($cronometro['id_proposta']);
        
        if(!$cronometro['id_aviso_encerramento']){
            return false;
        }
        //Verifica se o aviso vinculado está ativo
        $avisoEncerramento = $modelAvisosEncerramento->fetchAll([
          "id = {$cronometro['id_aviso_encerramento']}",
          "fl_ativo = 't'"
        ])->toArray();

        if($modelBeneficiarios->getBeneficiariosNaoBanco($cronometro['id_proposta'])){
            if($doc_segurado && $doc_beneficiarios && !empty($avisoEncerramento)){
                $dataLog = [
			        'id_status_atual' => $dadosCronometro['id_status'],
			        'ds_observacao' => "Contagem retomada",
			        'id_cronometro' => $dadosCronometro['id_cronometro'] 
		        ];
                $this->setLog($dataLog);
                return $modelCronometro->save($dadosCronometro);
            }else{
                return false;
            }
        }else{
            if(!$doc_segurado || empty($avisoEncerramento)){
                return false;
            }
            $dataLog = [
			        'id_status_atual' => $dadosCronometro['id_status'],
			        'ds_observacao' => "Contagem retomada",
			        'id_cronometro' => $dadosCronometro['id_cronometro'] 
		        ];
                $this->setLog($dataLog);
            return $modelCronometro->save($dadosCronometro);
        }

        
    }

    public function zerar($idCronometro, $ds_observacao = false){
        $modelStatus = new Sistema_Model_Status();
        return $this->atualizarStatus($idCronometro, $modelStatus->getId("PARADO", 'CONTADOR_REGULACAO'), $ds_observacao);
    }

    public function suspender($idCronometro, $observacao = false)
    {
        $modelStatus = new Sistema_Model_Status();

        return $this->atualizarStatus($idCronometro, $modelStatus->getId("SUSPENSO", 'CONTADOR_REGULACAO'), $observacao);
    }

    public function calculaIntervalo(string $data)
    {
        $dt_inicio = new DateTime($data);
        $intervalo = $dt_inicio->diff(new DateTime());
        $dias = $intervalo->days;
        return $dias;
    }

    public function finalizar($idCronometro, $observacao = false)
    {
        $modelStatus = new Sistema_Model_Status();
        return $this->atualizarStatus($idCronometro, $modelStatus->getId("FINALIZADO", 'CONTADOR_REGULACAO'), $observacao);
    }
    //calcula quantidade de dias que ficou com o cronometro rodando com o status 'ativo'
    public function calcularDiasRegulacaoValida($dados): int {
        if(!$dados['dt_inicio'] instanceof DateTimeInterface){
            $inicio = new DateTime($dados['dt_inicio']);
        }else{
            $inicio = $dados['dt_inicio'];
        }

        if(!$dados['dt_fim'] instanceof DateTimeInterface){
            $fim    = new DateTime($dados['dt_fim']);
        }else{
            $fim    = $dados['dt_fim'];
        }
        $diasTotal = $inicio->diff($fim)->days; // +1 para incluir o dia inicial
        
        $diasRegulado = ($dados['nr_dias_ativo'] + $diasTotal) - $dados['nr_dias_suspenso'];
        if($diasRegulado <= 0){
            $diasRegulado = 1;
        }
        return $diasRegulado;
    }

    public function getByLiquidacaoId($id): array
    {
        try{
            $sql = "select cr.* from sinistro.cronometro_regulacao cr join sinistro.avisos_encerramento_itens_segurados ais on ais.id_aviso_encerramento = cr.id_aviso_encerramento join sinistro.liquidacoes_itens_segurados_coberturas liq on liq.id_item_segurado = ais.id_item_segurado join sistema.status st on cr.id_status = st.id join sistema.tipo_status ts on ts.id = st.id_tipo_status where liq.id_liquidacao = {$id}";
            
            $rs = $this->_db->fetchRow($sql);
            return !$rs ? [] : $rs;
            
        }catch(Exception $e){
			$this->setMessage($e->getMessage());
			return [];
        }
 
    }
}