<?php

class Sinistro2_Model_Liquidacoes extends Agro_Db_Table_Abstract {
    const ID_STATUS_AGUARDANDO_ENVIO_SEGURADORA = 111;
    const ID_STATUS_AGUARDANDO_REVISAO = 184;
    const ID_STATUS_ENVIADA_SEGURADORA = 187;
    const ID_STATUS_ENVIADA_SEGURADORA_NAO_UTILIZADO = 112;
    const ID_STATUS_INDENIZACAO_PAGA = 113;
	const ID_STATUS_DEVOLVIDA_CORRECAO = 186;
    const ID_STATUS_SEM_INDENIZACAO = 193;
	const ID_STATUS_AGUARDANDO_PAGAMENTO = 316;

	protected $_schema = 'sinistro';
	protected $_name = 'liquidacoes';
	protected $_primary = 'id';
	public $_order = 'id';

	public function save($dados)
    {
		
        $Row = $this->getRow($dados ['id_liquidacao']);
        $ModelProcesso = new Sinistro2_Model_Processos ();

        //SE FOR INDENIZACAO PAGA
        if ($Row->id_status == 113) {
            $dados['id_status'] = $Row->id_status;
        }

        if ($dados['id_status']) {
            $RowProcesso = $ModelProcesso->getRow($Row->id_processo);

            if (!$this->isReplantio($dados['id_liquidacao'])) {
				$modelAvisoEncerramentoDataBase = new Sinistro2_Model_AvisosEncerramentoDataBase();
                $dt_ultima_data = $modelAvisoEncerramentoDataBase->getDataBaseByProposta($RowProcesso->id_proposta);

                if (empty($dt_ultima_data)) {
					$modelStatus 		= new Sistema_Model_Status();
					$modelCronometro 	= new Sinistro2_Model_CronometroRegulacao();
					$cronometro 		= $modelCronometro->getByLiquidacaoId($dados['id_liquidacao']);
					
					if($cronometro){
						if($cronometro['id_status'] == $modelStatus->getId("FINALIZADO", 'CONTADOR_REGULACAO')){
							$dt_ultima_data =  date('Y-m-d ', strtotime('+30 days', strtotime($cronometro['dt_fim'])));
							$dadosDataBase = [
								'id_aviso_encerramento' => $cronometro['id_aviso_encerramento'],
								'dt_base' => $dt_ultima_data
							];

							
							$modelAvisoEncerramentoDataBase->save($dadosDataBase);
							
						}
					}else{
                    	$Proposta = (new Seguro_Model_Propostas())->get($RowProcesso->id_proposta);
                    	$flIndenizacaoBeneficiario = true;

                    	// verifica se a liquidação tem direito a indenização de beneficiário
                    	if ($this->_db->fetchOne("select count(*) from sinistro.liquidacoes_itens_segurados_coberturas where id_liquidacao=" . $dados ['id_liquidacao'] . " and (id_cobertura=16 or id_cobertura=5 or id_cobertura=30 or id_cobertura=31 or id_cobertura=36 or id_cobertura=11)") > 0) {
                        	$flIndenizacaoBeneficiario = false;
                    	}

                    	$arDatas[] = $this->_db->fetchOne("select sinistro.liq_ultimo_aviso_encerramento(" . $dados ['id_liquidacao'] . ")");
                    	$Beneficiarios = $Proposta->beneficiarios();

                    	if (is_array($Beneficiarios) && $flIndenizacaoBeneficiario == true) {
                        	foreach ($Beneficiarios as $benef) {
                            	unset ($date);
                            	$date = str_replace('/', '-', $benef ['dt_ultimo_arquivo_beneficiario']);
                            	$arDatas [] = date('Y-m-d', strtotime($date));
                        	}
                    	}

                    	$arDatas[] = $this->_db->fetchOne("select sinistro.liq_ultimo_doc_segurado('" . $Row->id_processo . "')");
                    	$dt_ultima_data = max($arDatas);
					}
                }
            } else {
                $arDatas[] = $this->_db->fetchOne("select sinistro.liq_ultimo_aviso_final_replantio(" . $dados['id_liquidacao'] . ")");
                $arDatas[] = $this->_db->fetchOne("select sinistro.liq_ultimo_doc_segurado('" . $Row->id_processo . "')");
                $dt_ultima_data = max($arDatas);
            }
			//só atualiza a data pagamento caso ela ainda não tenha sido definida na liquidação
			if(!$Row->dt_base_pagamento){
				$Row->dt_base_pagamento = $dt_ultima_data;
			}
            $Row->id_status = $dados['id_status'];
            $Row->ds_observacao = $dados["ds_observacao"] ?? $Row->ds_observacao;
			
            $id = $Row->save();

            $Status = new Sinistro2_Model_LiquidacoesStatus ();
            $Status->save($id, $Row->id_status, $dados['ds_observacao']);
        } else {
            $Row->id_processo = $dados["id_processo"] ?? $Row->id_processo;
            $Row->tp_liquidacao = $dados["tp_liquidacao"] ?? $Row->tp_liquidacao;
            $Row->id_tipo_liquidacao = $dados["id_tipo_liquidacao"] ?? $Row->id_tipo_liquidacao;
            $Row->ds_observacao = $dados["ds_observacao"] ?? $Row->ds_observacao;

            $id = $Row->save();

            if ($id) {
                $Status = new Sinistro2_Model_LiquidacoesStatus ();
                $Status->save($id, Agro_Util::getIdStatus("AGUARDANDO_REVISAO"));

                $RowProcesso = $ModelProcesso->getRow($Row->id_processo);
                $RowProcesso->id_usuario_responsavel_liquidacao = Zend_Auth::getInstance()->getIdentity()->id;

                $RowProcesso->save();
            }
        }

        return $id;
    }

	public function getMapIdsLiquidacoesStatus(array $idsLiquidacoes)
	{
		$rs = $this->fetchAll(
			$this->select()
				->setIntegrityCheck(false)
				->from(['sl' => "{$this->_schema}.{$this->_name}"], 'id, id_status')
				->where('sl.id IN (?)', $idsLiquidacoes)
		);

		$map = [];
        foreach ($rs as $row) {
            $map[$row['id']] = $row['id_status'];
        }

        return $map;
	}

	public function atualizarStatusLiquidacoesImportacaoIndenizacao(
		array $idsLiquidacoes,
		array $idsLiquidacoesAtualizarStatus,
		int $idStatus,
		int $idRelatorioImportacaoIndenizacao
	): void
	{
		$usuario = Zend_Auth::getInstance()->getIdentity();

		$format = Zend_Date::YEAR . '-' . Zend_Date::MONTH . '-' . Zend_Date::DAY . ' ' .
			Zend_Date::HOUR . ':' . Zend_Date::MINUTE . ':' . Zend_Date::SECOND;

		$dataPagamento = Agro_Util::somarDataDiasUteis((new DateTime())->format('Y-m-d H:i:s'), 2, $format);
		$dataAtual = date('Y-m-d H:i:s');

		$mapIdliquidacaoPrevisaoPagamento = (new Sinistro2_Model_LiquidacoesPrevisaoPagamento())
            ->getMapPrevisoesPagamentoByIdsLiquidacoes($idsLiquidacoes);

		$idStatusPendentePagamento = (new Sistema_Model_Status())->getId(
			'PENDENTE_PAGAMENTO',
			'LIQUIDACAO_PAGAMENTO_ADICIONAL'
		);

		$idStatusAguardandoPagamento = (new Sistema_Model_Status())->getId(
			'AGUARDANDO_PAGAMENTO',
			'LIQUIDACAO_PAGAMENTO_ADICIONAL'
		);
		
		$mapIdLiquidacaoPagamentoAdicional = (new Sinistro2_Model_LiquidacaoPagamentoAdicional())
            ->getMapIdsLiquidacoesPagamentoAdicional($idsLiquidacoes, $idStatusPendentePagamento);
		
		$strIdsLiquidacoes = $strIdsLiquidacoesAtualizarStatus = $strIdsLiquidacoesPagamentoAdicional = '';
		$valuesPagamentoAdicional = $valuesPrevisaoPagamento = $valuesLiquidacoesStatus = $valuesRelatorioLiquidacoes = '';
		
		foreach ($idsLiquidacoes as $id) {
			$virgulaStatus = empty($valuesLiquidacoesStatus) ? '' : ',';
			$virgulaPrevisaoPagamento = empty($valuesPrevisaoPagamento) ? '' : ',';
			$virgulaPagamentoAdicional = empty($valuesPagamentoAdicional) ? '' : ',';
			$virgula = empty($valuesRelatorioLiquidacoes) ? '' : ',';
			
			if (!empty($idsLiquidacoesAtualizarStatus[$id])) {
				$strIdsLiquidacoesAtualizarStatus .= "{$virgulaStatus}{$id}";
				$valuesLiquidacoesStatus .= "{$virgulaStatus}({$id}, {$idStatus}, 'Status atualizado de forma automática com a geração do ";
				$valuesLiquidacoesStatus .= "relatório Importação Indenizações Agro, ID: {$idRelatorioImportacaoIndenizacao}', {$usuario->id})";
			}

			if (empty($mapIdliquidacaoPrevisaoPagamento[$id])) {
				$valuesPrevisaoPagamento .= "{$virgulaPrevisaoPagamento}({$id}, '{$dataPagamento}', {$usuario->id})";
			}

			if (!empty($mapIdLiquidacaoPagamentoAdicional[$id])) {
				$pagamentoAdicional = $mapIdLiquidacaoPagamentoAdicional[$id];
				$strIdsLiquidacoesPagamentoAdicional .= "{$virgulaPagamentoAdicional}{$id}";

				$valuesPagamentoAdicional .= "{$virgulaPagamentoAdicional}({$id}, {$idStatusAguardandoPagamento}, {$pagamentoAdicional['id_usuario_criacao']}, $usuario->id";
				$valuesPagamentoAdicional .= ", {$pagamentoAdicional['vl_indenizacao_paga']}, {$pagamentoAdicional['vl_total_corrigido']}, '{$pagamentoAdicional['ds_observacao']}'";
				$valuesPagamentoAdicional .= ", '{$pagamentoAdicional['ds_nome_arquivo']}')";
			}
			
			$valuesRelatorioLiquidacoes .= "{$virgula}({$idRelatorioImportacaoIndenizacao}, {$id}, {$usuario->id})";
			$strIdsLiquidacoes .= "{$virgula}{$id}";
		}

		// Vincula liquidação com relatório
		$this->_db->query("INSERT INTO sinistro.relatorio_importacao_indenizacao_liquidacao (id_relatorio_importacao_indenizacao, id_liquidacao, id_usuario_criacao) VALUES {$valuesRelatorioLiquidacoes}");

		if (!empty($valuesLiquidacoesStatus)) {
			$this->_db->query("UPDATE sinistro.liquidacoes_status SET fl_ativo = FALSE WHERE id_liquidacao IN({$strIdsLiquidacoesAtualizarStatus})");
			$this->_db->query("INSERT INTO sinistro.liquidacoes_status (id_liquidacao, id_status, ds_observacao, id_usuario_criacao) VALUES {$valuesLiquidacoesStatus}");
			$this->_db->query("UPDATE sinistro.liquidacoes SET id_status = {$idStatus} WHERE id IN({$strIdsLiquidacoesAtualizarStatus})");
		}

		if (!empty($valuesPagamentoAdicional)) {
			$this->_db->query("UPDATE sinistro.liquidacao_pagamento_adicional SET fl_ativo = FALSE WHERE id_liquidacao IN({$strIdsLiquidacoesPagamentoAdicional}) AND fl_ativo IS TRUE");
			$this->_db->query("INSERT INTO
				sinistro.liquidacao_pagamento_adicional (
					id_liquidacao, id_status, id_usuario_criacao,
					id_usuario_alteracao, vl_indenizacao_paga, vl_total_corrigido,
					ds_observacao, ds_nome_arquivo
				)
				VALUES {$valuesPagamentoAdicional}"
			);
		}

		if(!empty($valuesPrevisaoPagamento)) {
			$this->_db->query("INSERT INTO sinistro.liquidacoes_previsao_pagamento (id_liquidacao, dt_pagamento, id_usuario_criacao) VALUES {$valuesPrevisaoPagamento}");
		}

		// Atualiza data estimada pagamento
		$this->_db->query("UPDATE sinistro.liquidacoes_previsao_pagamento SET dt_pagamento = '{$dataPagamento}', dt_alteracao = '{$dataAtual}' WHERE id_liquidacao IN({$strIdsLiquidacoes})");
	}

	public function atualizarStatusLiquidacoesProcesso(
		int $idProcesso,
		int $idStatusAtualizar,
		int $idStatusAlvo = 0
	): array {
		$select = $this->select()
			->where('id_processo = ?', $idProcesso)
			->where('id_status = ?', $idStatusAlvo);

		$rs = $this->fetchAll($select)->toArray();

		$where = "id_processo = {$idProcesso}";

		if ($idStatusAlvo != 0) {
			$where .= " AND id_status = {$idStatusAlvo}";
		}

		$this->update(['id_status' => $idStatusAtualizar], $where);

		return $rs;
	}


	public function liquidarZerado($dados){

		$result = array("status"=>true, "message"=>"", "execute"=>"");

		$this->getAdapter()->beginTransaction();

		$ModelLiquidacoesIS = new Sinistro2_Model_LiquidacoesItensSeguradosCoberturas();

		try {
			if(
				$ModelLiquidacoesIS->save(
					array(
							"id_liquidacao" 		 => $dados["id_liquidacao"],
							"id_item_segurado" 		 => $dados["id_item_segurado"],
							"id_cobertura" 			 => $dados["id_cobertura"],
							"vl_percent_franquia" 	 => 0,
							"vl_franquia" 			 => 0,
							"vl_indenizacao" 		 => 0,
							"vl_prejuizo_total" 	 => 0,
							"vl_percent_indenizacao" => 0
					)
			)){
				$result['message'] = "Liquidação realizada com sucesso";
				$this->getAdapter()->commit();
			} else {
				$result['message'] = "Erro ao realizar liquidação";
				$this->getAdapter()->rollBack();
			}

		} catch (Exception $e) {
			$this->getAdapter()->rollBack();
			$result['status'] = false;
			$result['message'] = "Não foi possível realizar a liquidação. \n {$e->getMessage()}";
		}

		return $result;
	}


	public function getLiquidacoes($id_proposta, $id_processo) {
		$Select = $this->select()->setIntegrityCheck(false);

		$Select->from(array("lf" => "sinistro.laudos_finais"), false);

		$Select->joinInner(array("p" => "sinistro.processos"), "p.id = lf.id_processo", 'id_status_arquivos');
		$Select->joinInner(array("pc" => "seguro.propostas_coberturas"), "pc.id_proposta = p.id_proposta", false);
		$Select->joinInner(array("pco" => "produto.produtos_coberturas"), "pco.id_cobertura = pc.id_cobertura", false);
		$Select->joinInner(array("iseg" => "seguro.itens_segurados"), "iseg.id_proposta = p.id_proposta", array("iseg.id_proposta", "iseg.id as id_item_segurado", "iseg.ds_item_segurado", "iseg.vl_area", "iseg.vl_lmga"));
		$Select->joinInner(array("v" => "produto.variedades"), "v.id = iseg.id_variedade", "v.ds_nome_variedade");
		$Select->joinInner(array("l" => "sinistro.liquidacoes"), "l.id_processo = p.id", "l.id as id_liquidacao");

		$Select->where("lf.id_processo = $id_processo");
		$Select->where("p.id_proposta = $id_proposta");

		$Select->order('iseg.id');

		$Row = $this->fetchAll($Select);

		$result = array();

		if ($Row) {
			$itens = $Row->toArray();

			foreach ($itens as $iten) {
				$prejuizo_total = 0;

				$Laudos = $this->getLaudosLiquidados($iten['id_liquidacao'], $iten['id_item_segurado']);

				$iten["LAUDOS"] = $Laudos;

				foreach ($Laudos as $laudo) {
					$prejuizo_total += $laudo['vl_prejuizo'];
				}

				$iten['prejuizo_total'] = $prejuizo_total;
				$iten['franquia'] = 0;
				$iten['indenizacao'] = 0;

				$result[] = $iten;
			}
		}
		return $result;
	}

	public function getCoberturasLiquidacaoByProposta($idProposta) {
		$data = array();
		if ($idProposta) {
			$select = "
			select
				c.id,
				c.ds_nome_cobertura,
				pdc.fl_vistoria_preliminar,
				pdc.fl_vistoria_final,
				pdc.fl_exibir_regulacao_perdas,
				pdc.id_tipo_liquidacao,
				tl.fl_liquidacao_avulsa,
				tl.fl_liquidacao_manual,
				pe.id_empresa as id_empresa_processo
				/*, av.fl_dispensa_preliminar */

			from
				/*tabela que tem o id_proposta*/
				sinistro.avisos as av inner join

				/*busca a empresa do processo*/
				sinistro.processos as pro on pro.id_proposta = av.id_proposta inner join
				sinistro.processos_empresas as pe on pe.id_processo = pro.id and pe.fl_ativo = true inner join

				/*busca as coberturas da proposta*/
				seguro.propostas_coberturas as pc on pc.id_proposta = av.id_proposta inner join
				produto.coberturas as c on c.id = pc.id_cobertura left join

				/*filtra pelos eventos das coberturas*/
				sinistro.avisos_eventos as ae on ae.id_aviso = av.id left join
				produto.coberturas_eventos as ce on ce.id_evento = ae.id_evento and ce.id_cobertura = c.id inner join

				/*filtra por produto*/
				seguro.propostas pr on pr.id = av.id_proposta inner join
				seguro.propostas_endosso pre on pre.id_proposta = pr.id and pre.fl_proposta_vigente = true inner join
				produto.produtos pd on pd.id = pr.id_produto inner join
				produto.produtos_coberturas pdc on pdc.id_cobertura = c.id and pdc.id_produto = pr.id_produto left outer join
				sinistro.tipo_liquidacao tl on tl.id = pdc.id_tipo_liquidacao

			where
				pre.id_endosso in (select id_endosso from seguro.propostas where id in ($idProposta)) and
				pdc.fl_cobertura_dependente = false and
				c.fl_ativo = true
			group by
				c.id,
				c.ds_nome_cobertura,
				pdc.fl_vistoria_preliminar,
				pdc.fl_vistoria_final,
				pdc.fl_exibir_regulacao_perdas,
				pdc.id_tipo_liquidacao,
				tl.fl_liquidacao_avulsa,
				tl.fl_liquidacao_manual,
				pe.id_empresa
				/*, av.fl_dispensa_preliminar */
			order by
			c.id
			";

			$data = $this->_db->fetchAll($select);
		}
		return $data;
	}

	public function getPercentConvertido($vlPercentPerdas) {
		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array('aux' => 'sinistro.auxiliar_liquidacao_uva_mesa_conversao'), 'aux.vl_percent_correcao');
		$Select->where('? between aux.vl_percent_perdas_min and aux.vl_percent_perdas_max', $vlPercentPerdas);

		return $this->_db->fetchOne($Select);
	}

	public function getPropostaByLiquidacao($id_liquidacao) {
		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array('l' => 'sinistro.liquidacoes'),null);
		$Select->join(array('pc' => 'sinistro.processos'), 'pc.id = l.id_processo', 'pc.id_proposta');
		$Select->where("l.id = ?", $id_liquidacao);
		return $this->_db->fetchOne($Select);
	}
	
	public function isReplantio($id_liquidacao) {
	    $Select = $this->select()->distinct(true)->setIntegrityCheck(false);
	    $Select->from(array('l' => 'sinistro.liquidacoes_itens_segurados_coberturas'),'id_liquidacao');
	    $Select->where("l.id_liquidacao = ?", $id_liquidacao);
	    $Select->where("l.id_cobertura in (5, 30, 31, 36)", $id_liquidacao);
	    $rs = $this->_db->fetchAll($Select);

	    if(count($rs) > 0){
	        return true;
	    } else {
	        return false;
	    }
	}
	
	
	public function getLiquidacao($id_liquidacao) {
		$ModelProposta = new Seguro_Model_Propostas();

		$result = array();

		//Busca informações da proposta e do processo
		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array('l' => 'sinistro.liquidacoes'), array('l.id as id_liquidacao', 'l.id_tipo_liquidacao', 'l.tp_liquidacao',"l.ds_observacao", "dt_base_pagamento"));
		//$Select->join(array('pc' => 'sinistro.processos'), 'pc.id = l.id_processo', array('pc.id as id_processo', 'seguro.id_proposta_mae(pc.id_proposta) as id_proposta'));
		$Select->join(array('pc' => 'sinistro.processos'), 'pc.id = l.id_processo', array('pc.id as id_processo', 'pc.id_proposta', 'id_status_arquivos')); //estava pegando beneficiario errado
		$Select->join(array('st' => 'sistema.status'), 'st.id = l.id_status', array('st.ds_chave'));
		$Select->join(array('st_arquivo'=>'sistema.status'), 'st_arquivo.id = pc.id_status_arquivos', array('st_arquivo.ds_status as ds_status_arquivo'));
		$Select->join(array('tl' => 'sinistro.tipo_liquidacao'), 'tl.id = l.id_tipo_liquidacao', array('tl.ds_chave as tipo_liquidacao'));
		$Select->where("l.id = ?", $id_liquidacao);

		$Row = $this->fetchRow($Select);

		foreach ($Row as $key => $value) {
			$result[$key] = $value;
		}
		$Proposta = $ModelProposta->find($result["id_proposta"])->current();
		$Produto = $Proposta->produto();

		//Busca informações do rodapé
		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array('l' => 'sinistro.liquidacoes'), array('id_usuario_criacao', 'dt_criacao'));
		$Select->where("l.id = ?", $id_liquidacao);

		$Row = $this->fetchRow($Select);

		$Model = new Sistema_Model_Usuarios();
		$usuario = $Model->getUsuarioById($Row->id_usuario_criacao);
		$result['responsavel'] = $usuario;
		$result['data'] = $Row->dt_criacao;

		// Busca informações da liquidação: franquia e indenização por item segurado/cobertura
		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array('l' => 'sinistro.liquidacoes'), 'l.id as id_liquidacao');
		$Select->join(array('lisc' => 'sinistro.liquidacoes_itens_segurados_coberturas'), 'lisc.id_liquidacao = l.id', array('lisc.vl_franquia', 'lisc.vl_percent_franquia', 'lisc.vl_indenizacao', 'lisc.vl_percent_indenizacao', 'lisc.id_item_segurado', 'lisc.id_cobertura', 'lisc.vl_prejuizo_total'));
		$Select->join(array('c' => 'produto.coberturas'), 'c.id = lisc.id_cobertura', 'c.ds_nome_cobertura');
		$Select->join(array("ise" => "seguro.itens_segurados"), "ise.id = lisc.id_item_segurado", false);
		
		$Select->where('l.id = ?', $id_liquidacao);
		$Select->order(array('l.id', 'ise.nr_item_segurado'));

		$Row = $this->fetchAll($Select);

		$result['itens_segurados'] = array();
		$result['vl_indenizacao_total'] = 0;
		$result['vl_franquia_total'] = 0;

		if ($Row) {
			$LiquidacoesItensSeguradosCobertura = $Row->toArray();

			foreach ($LiquidacoesItensSeguradosCobertura as $LiquidacaoItemSeguradoCobertura) {
				$result['itens_segurados'][$LiquidacaoItemSeguradoCobertura['id_item_segurado']]['indenizacao'][] = array(
					'id_cobertura' => $LiquidacaoItemSeguradoCobertura['id_cobertura'],
					'ds_nome_cobertura' => $LiquidacaoItemSeguradoCobertura['ds_nome_cobertura'],
					'vl_percent_franquia' => $LiquidacaoItemSeguradoCobertura['vl_percent_franquia'],
					'vl_franquia' => $LiquidacaoItemSeguradoCobertura['vl_franquia'],
					'vl_prejuizo_total' => $LiquidacaoItemSeguradoCobertura['vl_prejuizo_total'],
					'vl_indenizacao' => ($LiquidacaoItemSeguradoCobertura['vl_indenizacao'] > 0 ? $LiquidacaoItemSeguradoCobertura['vl_indenizacao'] : 0),
					'vl_percent_indenizacao' => ($LiquidacaoItemSeguradoCobertura['vl_percent_indenizacao'] > 0 ? $LiquidacaoItemSeguradoCobertura['vl_percent_indenizacao'] : 0)
				);

				$result['itens_segurados'][$LiquidacaoItemSeguradoCobertura['id_item_segurado']]['vl_indenizacao_total'] += $LiquidacaoItemSeguradoCobertura['vl_indenizacao'];
				$result['itens_segurados'][$LiquidacaoItemSeguradoCobertura['id_item_segurado']]['vl_prejuizo_total'] += $LiquidacaoItemSeguradoCobertura['vl_prejuizo_total'];
				$result['vl_indenizacao_total'] += ($LiquidacaoItemSeguradoCobertura['vl_indenizacao'] > 0 ? $LiquidacaoItemSeguradoCobertura['vl_indenizacao'] : 0);
				$result['vl_franquia_total'] += $LiquidacaoItemSeguradoCobertura['vl_franquia'];
				$result['vl_prejuizo_total'] += $LiquidacaoItemSeguradoCobertura['vl_prejuizo_total'];
			}

			if ($result['tipo_liquidacao'] === 'LIQ17') {
                $result['vl_indenizacao_total'] = $this->getValorIndenizacaoLiq17((int) $id_liquidacao);
            }
		}

		// Busca informações da liquidação: prejuizo por item segurado/cobertura/laudo
		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array('l' => 'sinistro.liquidacoes'), 'l.id as id_liquidacao');
		$Select->join(array('lisc' => 'sinistro.liquidacoes_itens_segurados_coberturas'), 'lisc.id_liquidacao = l.id and lisc.fl_dependente = false', array('lisc.id_item_segurado', 'lisc.id_cobertura'));
		$Select->join(array('lisclf' => 'sinistro.liquidacoes_itens_segurados_coberturas_lf'), 'lisclf.id_liquidacoes_itens_segurados_coberturas = lisc.id', array('lisclf.vl_prejuizo', 'id as id_liquidacoes_itens_segurados_coberturas_lf', 'lisclf.vl_percent_dano'));
		$Select->join(array('lfis' => 'sinistro.laudos_finais_itens_segurados'), 'lfis.id = lisclf.id_laudo_final_item_segurado', array('lfis.vl_percent_perdas', 'lfis.vl_percent_colhido', 'lfis.vl_percent_perdas_chocho', 'lfis.vl_percent_colhido_chocho'));
		$Select->join(array('c' => 'produto.coberturas'), 'c.id = lisc.id_cobertura', 'c.ds_nome_cobertura');
		$Select->where('l.id = ?', $id_liquidacao);
		$Select->order(array('l.id', 'lisclf.id')); 

		$Rows = $this->fetchAll($Select);

		$result['vl_area_total'] = 0;
		$result['vl_lmga_total'] = 0;

		if ($Rows) {
			$LiquidacaoItensSegurados = $Rows->toArray();


			foreach ($LiquidacaoItensSegurados as $LiquidacaoItemSegurado) {
				// Busca informações da liquidação: prejuizo por item segurado/laudo/cobertura dependente
				$Select = $this->select()->setIntegrityCheck(false);
				$Select->from(array('liscd' => 'sinistro.liquidacoes_itens_segurados_coberturas_lf_dependentes'), array('liscd.vl_prejuizo', 'liscd.vl_percent_perdas'));
				$Select->join(array('lisc' => 'sinistro.liquidacoes_itens_segurados_coberturas'), 'lisc.id = liscd.id_liquidacoes_itens_segurados_coberturas', array('lisc.vl_indenizacao', 'vl_percent_indenizacao'));
				$Select->join(array('c' => 'produto.coberturas'), 'c.id = lisc.id_cobertura', 'c.ds_nome_cobertura');
				$Select->where('liscd.id_liquidacoes_itens_segurados_coberturas_lf = ?', $LiquidacaoItemSegurado['id_liquidacoes_itens_segurados_coberturas_lf']);
				$Select->order(array('liscd.nr_prioridade'));
				$Rows = $this->fetchAll($Select);
				if ($Rows) {
					$LiquidacaoCoberturasDependentes = $Rows->toArray();
					$LiquidacaoItemSegurado['liquidacoes_dependentes'] = array();
					foreach ($LiquidacaoCoberturasDependentes as $LiquidacaoCoberturaDependente) {
						$LiquidacaoItemSegurado['liquidacoes_dependentes'][] = $LiquidacaoCoberturaDependente;
					}
				}

				if (in_array($Produto['ds_chave_produto'], array('UVA_MESA_TABELA_II', 'UVA_MESA_TABELA_II_S2', 'UVA_VINHO_TABELA_II'))) {
					$LiquidacaoItemSegurado['percentual_convertido'] = $this->getPercentConvertido($LiquidacaoItemSegurado['vl_percent_perdas']);
				} else {
					$LiquidacaoItemSegurado['percentual_convertido'] = false;
				}

				$result['itens_segurados'][$LiquidacaoItemSegurado['id_item_segurado']]['liquidacoes'][] = $LiquidacaoItemSegurado;
			}

			$ModelItensSegurados = new Seguro_Model_ItensSegurados();
			$ModelItensSeguradoComp = new Seguro_Model_ItensSeguradosComplementos();

			foreach ($result['itens_segurados'] as $id_item_segurado => $liquidacao_item_segurado) {

				$ItemSegurado = $ModelItensSegurados->getItemSeguradoById($id_item_segurado);
				$ISC = $ModelItensSeguradoComp->find($id_item_segurado)->current();
				$IS = $ModelItensSegurados->find($id_item_segurado)->current();

				$result['itens_segurados'][$id_item_segurado]['id_item_segurado'] = $id_item_segurado;
				$result['itens_segurados'][$id_item_segurado]['nr_item_segurado'] = $ItemSegurado['nr_item_segurado'];
				$result['itens_segurados'][$id_item_segurado]['ds_item_segurado'] = $ItemSegurado['ds_item_segurado'];
				$result['itens_segurados'][$id_item_segurado]['vl_area'] = $ItemSegurado['vl_area'];
				$result['itens_segurados'][$id_item_segurado]['vl_area_atingida'] = ($this->getAreaAtingida($id_liquidacao, $id_item_segurado) ? $this->getAreaAtingida($id_liquidacao, $id_item_segurado) : $ItemSegurado['vl_area']);
				$result['itens_segurados'][$id_item_segurado]['vl_lmga'] = $ItemSegurado['vl_lmga'];
				$result['itens_segurados'][$id_item_segurado]['ds_nome_variedade'] = $ItemSegurado['ds_nome_variedade'];
				$result['itens_segurados'][$id_item_segurado]['dt_encerramento_colheita'] = $ItemSegurado['dt_encerramento_colheita'];
                $result['itens_segurados'][$id_item_segurado]['vl_rendimento_tonelada'] = $ItemSegurado['vl_rendimento_tonelada'];

				if ($Proposta->isPg() && $result["tipo_liquidacao"] != "LIQ05") {
					$result['itens_segurados'][$id_item_segurado]['vl_producao_garantida'] = $ISC["vl_producao_garantida"];
					$result['itens_segurados'][$id_item_segurado]['vl_rendimento_final_lavoura'] = $this->getRendimentoFinalLavoura($id_liquidacao, $id_item_segurado);
				}
				
 				if ($result['tipo_liquidacao'] == 'LIQ16' || $result['tipo_liquidacao'] == 'LIQ18') {
					$ModelLF026ItensSegurado = new Regulacao_Model_Lf026ItensSegurados();
					$Item = $ModelLF026ItensSegurado->getDadaByIdItemLaudo($id_item_segurado);

					$result['itens_segurados'][$id_item_segurado]['vl_ha_area_replantada'] = 0;
						$result['itens_segurados'][$id_item_segurado]['percent_area_replantada'] = 0;
						$result['itens_segurados'][$id_item_segurado]['lmga_area_replantada'] = 0;
					if ($Item) {
						$result['itens_segurados'][$id_item_segurado]['vl_ha_area_replantada'] = $Item['vl_ha_area_replantada'];
						$result['itens_segurados'][$id_item_segurado]['percent_area_replantada'] =  ($Item['vl_ha_area_replantada']/$ItemSegurado['vl_area']) * 100;
						$result['itens_segurados'][$id_item_segurado]['lmga_area_replantada'] = $ItemSegurado['vl_lmga']*($Item['vl_ha_area_replantada']/$ItemSegurado['vl_area']);
					}
				}

				$result['vl_lmga_total'] += $ItemSegurado['vl_lmga'];
				$result['vl_area_total'] += $ItemSegurado['vl_area'];
			}
		}

		return $result;
	}

	public function getAreaAtingida($id_liquidacao, $id_item_segurado) {
		$sql = "
    		SELECT
				max(lfis.id),
			    lfis.vl_ha_area_afetada
			FROM
				sinistro.liquidacoes_itens_segurados_coberturas_lf lisclf inner join
			    sinistro.laudos_finais_itens_segurados lfis on lfis.id = lisclf.id_laudo_final_item_segurado inner join
			    sinistro.liquidacoes_itens_segurados_coberturas lisc on lisc.id = lisclf.id_liquidacoes_itens_segurados_coberturas inner join
			    sinistro.liquidacoes l on l.id = lisc.id_liquidacao
			WHERE
				(l.id = $id_liquidacao) AND
			    (lfis.id_item_segurado = $id_item_segurado)
			group by
				vl_ha_area_afetada";

		$Row = $this->_db->fetchRow($sql);

		return ($Row["vl_ha_area_afetada"] ? $Row["vl_ha_area_afetada"] : false);
	}

	public function getRendimentoFinalLavoura($id_liquidacao, $id_item_segurado) {
		$sql = "
    		SELECT
				max(lfis.id_item_segurado),
			    lfis.vl_rendimento_final_lavoura
			FROM
				sinistro.liquidacoes_itens_segurados_coberturas_lf lisclf inner join
			    sinistro.laudos_finais_itens_segurados  lfis on lfis.id = lisclf.id_laudo_final_item_segurado inner join
			    sinistro.liquidacoes_itens_segurados_coberturas lisc on  lisc.id = lisclf.id_liquidacoes_itens_segurados_coberturas inner join
				sinistro.liquidacoes l on l.id = lisc.id_liquidacao

			WHERE
				(l.id = $id_liquidacao) AND
			    (lfis.id_item_segurado = $id_item_segurado)
			group by
				vl_rendimento_final_lavoura";

		$Row = $this->_db->fetchRow($sql);

		return $Row["vl_rendimento_final_lavoura"];
	}

	public function getLaudosLiquidados($id_liquidacao, $id_item_segurado) {
		$Laudos = false;

		$Select = $this->select()->setIntegrityCheck(false);

		$Select->from(array("lis" => "sinistro.liquidacoes_laudos_finais_itens_segurados"), array("lis.vl_prejuizo", 'lis.vl_indenizacao'));

		$Select->joinInner(array("lfis" => "sinistro.laudos_finais_itens_segurados"), "lfis.id = lis.id_laudo_final_item_segurado", array("lfis.vl_rendimento_final_lavoura"));
		$Select->joinInner(array("lf" => "sinistro.laudos_finais"), "lf.id = lfis.id_laudo_final", false);
		$Select->joinInner(array("pc" => "produto.produtos_coberturas"), "pc.id_cobertura = lf.id_cobertura", false);
		$Select->joinInner(array("c" => "produto.coberturas"), "pc.id_cobertura = c.id", "c.ds_nome_cobertura");

		$Select->where("lis.id_liquidacao = $id_liquidacao");
		$Select->where("lfis.id_item_segurado = $id_item_segurado");

		$Row = $this->fetchAll($Select);

		if ($Row) {
			$ArrLaudos = $Row->toArray();

			$Laudos = array();
			foreach ($ArrLaudos as $laudo) {
				$laudo["dependente"] = false;

				$Laudos[] = $laudo;
			}
		}

		return $Laudos;
	}

	public function beforeDelete($dados) {

		try {
			$ModelLiquidacoesCanceladas = new Sinistro2_Model_LiquidacoesCanceladas();
			$ModelLiquidacoesCanceladas->save($dados);

			$ModelLiquidacoesItensSeguradosCoberturas = new Sinistro2_Model_LiquidacoesItensSeguradosCoberturas();
			$ModelLiquidacaoItensSeguradosCoberturasLf = new Sinistro2_Model_LiquidacoesItensSeguradosCoberturasLF();
			$ModelLiquidacaoItensSeguradosCoberturasLfDependente = new Sinistro2_Model_LiquidacoesItensSeguradosCoberturasLFDependentes();
			$ModelLiquidacoesStatus = new Sinistro2_Model_LiquidacoesStatus();
			$ModelLiquidacoesStatus->delete($dados['id_liquidacao'], 'id_liquidacao');

			$RowLISC = $ModelLiquidacoesItensSeguradosCoberturas->fetchAll("id_liquidacao = " . $dados["id_liquidacao"]);

			foreach ($RowLISC as $Item) {
				$ModelLiquidacaoItensSeguradosCoberturasLfDependente->delete($Item->id, "id_liquidacoes_itens_segurados_coberturas");
				$ModelLiquidacaoItensSeguradosCoberturasLf->delete($Item->id, "id_liquidacoes_itens_segurados_coberturas");
			}

			$ModelLiquidacoesItensSeguradosCoberturas->delete($dados['id_liquidacao'], "id_liquidacao");

			return true;
		} catch (Exception $e) {
			$this->setMessage($e->getMessage());
			return false;
		}
	}

	public function getLiquidacoesByProcessoCobertura($idProcesso, $cobertura) {

		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array('l' => 'sinistro.liquidacoes'), array('l.id as id_liquidacao', "to_char(l.dt_criacao,'DD/MM/YYYY') as dt_realizada_em", "l.id_status as id_status", "l.ds_arquivo_liquidacao_manual as arquivo", "id_tipo_liquidacao"));
		$Select->join(array('lic' => 'sinistro.liquidacoes_itens_segurados_coberturas'), 'lic.id_liquidacao = l.id', false);
		$Select->join(array('cob' => 'produto.coberturas'), 'cob.id = lic.id_cobertura', 'ds_nome_cobertura');
		$Select->where('l.id_processo = ?', $idProcesso);
		$Select->where('lic.id_cobertura = ?', $cobertura);

		$Select->group(array('l.id', 'l.dt_criacao', 'l.id_status', 'l.ds_arquivo_liquidacao_manual', 'id_tipo_liquidacao', 'ds_nome_cobertura'));

		return $this->fetchAll($Select)->toArray();
	}

	public function getLiquidacoesByProcessoLiquidacaoTipo($idProcesso) {
		$User = Zend_Auth::getInstance()->getIdentity();

		$Select = $this->select()->distinct(true)->setIntegrityCheck(false);
		$Select->from(array('l'   => 'sinistro.liquidacoes'), array('(select sum(vl_indenizacao) from sinistro.liquidacoes_itens_segurados_coberturas where id_liquidacao=l.id) as vl_indenizacao', 'l.id as id_liquidacao', "to_char(l.dt_criacao,'DD/MM/YYYY') as dt_realizada_em", "l.id_status as id_status", "l.ds_arquivo_liquidacao_manual as arquivo", "id_tipo_liquidacao"));
		$Select->join(array('lic' => 'sinistro.liquidacoes_itens_segurados_coberturas'), 'lic.id_liquidacao = l.id', false);
		$Select->join(array('cob' => 'produto.coberturas'), 'cob.id = lic.id_cobertura', "array_to_string(array_agg(cob.ds_nome_cobertura::text) OVER (PARTITION BY l.id), ', ') as ds_nome_cobertura");
		$Select->join(array('tl'  => 'sinistro.tipo_liquidacao'), 'tl.id = l.id_tipo_liquidacao', array('ds_chave'));
		$Select->join(array('st'  => 'sistema.status'), 'st.id = l.id_status', false);
		$Select->join(array('sf'  => 'sistema.funcionarios'), 'sf.id_usuario = l.id_usuario_criacao', ['ds_nome_funcionario']);
		$Select->where('l.id_processo = ?', $idProcesso);

		if($User->id_empresa <> 20){
			$Select->where("st.ds_chave in ('SEM_INDENIZACAO', 'ENVIADA_SEGURADORA','ENVIADA_SEGURADORA_EXCEL', 'INDENIZACAO_PAGA')");
		}

		$Select->group(array('l.id', 'l.dt_criacao', 'l.id_status', 'l.ds_arquivo_liquidacao_manual', 'tl.ds_chave', 'cob.ds_nome_cobertura', 'ds_nome_funcionario'));
		$Select->order("l.id asc");
		
		return $this->fetchAll($Select)->toArray();
	}

	public function getIdsCoberturas(int $idLiquidacao) 
	{
		return $this->fetchAll(
			$this->select()
				->setIntegrityCheck(false)
				->from(['sl' => 'sinistro.liquidacoes'], false)
				->join(['sp' => 'sinistro.processos'], 'sp.id = sl.id_processo', false)
				->join(['sprop' => 'seguro.propostas'], 'sprop.id = sp.id_proposta', false)
				->join(['sli' => 'sinistro.liquidacoes_itens_segurados_coberturas'], 'sli.id_liquidacao = sl.id', 'id_cobertura')
				->join(['ppc' => 'produto.produtos_coberturas'], 'ppc.id_produto = sprop.id_produto AND ppc.id_cobertura = sli.id_cobertura', 'fl_cobertura_principal')
				->group('sl.id, sli.id_cobertura, fl_cobertura_principal')
				->where('sl.id = ?', $idLiquidacao)
		);
	}

	public function getLiquidacoesAvulsasByProcessoCobertura($idProcesso, $cobertura) {
		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array('l' => 'sinistro.liquidacoes'), array('l.id as id_liquidacao', "to_char(l.dt_criacao,'DD/MM/YYYY') as dt_realizada_em", "l.id_status as id_status", "l.ds_arquivo_liquidacao_manual as arquivo", "id_tipo_liquidacao", "coberturas"));
		$Select->join(array('lic' => 'sinistro.liquidacoes_itens_segurados_coberturas'), 'lic.id_liquidacao = l.id', array("id_cobertura"));
		$Select->where('l.id_processo = ?', $idProcesso);

		if (is_array($cobertura)) {
			$ids_coberturas = implode(',', $cobertura);
			$Select->where("lic.id_cobertura in ($ids_coberturas)");
		} else {
			if ($cobertura) {
				$Select->where('lic.id_cobertura = ', $cobertura);
			}
		}

		$Select->group(array('l.id', 'l.dt_criacao', 'l.id_status', 'l.ds_arquivo_liquidacao_manual', 'id_tipo_liquidacao', 'id_cobertura'));

		return $this->fetchAll($Select);
	}

	public function getStatusLiquidacao($idLiquidacao) {
		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array('s' => 'sistema.status'), array('s.ds_status as ds_status', 's.ds_chave as ds_chave'));
		$Select->join(array('l' => 'sinistro.liquidacoes'), 'l.id_status = s.id', false);
		$Select->where('s.id_tipo_status = ?', 9);
		$Select->where('l.id = ?', $idLiquidacao);

		$Row = $this->getAdapter()->fetchRow($Select);

		return ($Row ? $Row : false);
	}

	public function atualizaStatusLiquidacao($idLiquidacao, $idStatus, $atualizarHistoricoStatus = true) {
		$User = Zend_Auth::getInstance()->getIdentity();
		$Status = new Sinistro2_Model_LiquidacoesStatus();
		$ModelLiquidacao = new Sinistro2_Model_Liquidacoes();
		$retornoStatus = null;

        if ($atualizarHistoricoStatus) {
            $retornoStatus = $Status->save($idLiquidacao, $idStatus);
        }

        if ($retornoStatus || !$atualizarHistoricoStatus) {
            $Liquidacao = $ModelLiquidacao->find($idLiquidacao)->current();
            $Liquidacao->id_status = $idStatus;
            $Liquidacao->dt_alteracao = Zend_Date::now();
            $Liquidacao->id_usuario_alteracao = $User->id;

            return $Liquidacao->save();
        }
	}

	public function getListaLiquidacoes($id_proposta, $id_processo) {
		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array("l" => "sinistro.liquidacoes"), array('l.id'));
		$Select->joinInner(array("p" => "sinistro.processos"), "l.id_processo = p.id", false);
		$Select->join(array("lc" => "sinistro.liquidacoes_itens_segurados_coberturas"), "lc.id_liquidacao = l.id", 'sum(vl_indenizacao) as vl_indenizacao');
		$Select->group(array("l.id"));
		$Select->where("l.id_processo = $id_processo");
		$Select->where("p.id_proposta = $id_proposta");
		//trazer apenas os não pagos
		//$Select->where("l.id not in(SELECT id_liquidacao FROM sinistro.liquidacoes_pagamentos)");
		return $this->fetchAll($Select);
	}

	public function getListaLiquidacoesPorPagamento($id_proposta, $id_processo, $id_pagamento) {
		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array("l" => "sinistro.liquidacoes"), array('l.id'));
		$Select->joinInner(array("p" => "sinistro.processos"), "l.id_processo = p.id", false);
		$Select->join(array("lc" => "sinistro.liquidacoes_itens_segurados_coberturas"), "lc.id_liquidacao = l.id", false);
		//$Select->join(array("lp" => "sinistro.liquidacoes_pagamentos"), "lp.id_liquidacao = l.id", false);
		//$Select->join(array("lpp" => "sinistro.liquidacoes_previsao_pagamento"), "lpp.id_liquidacao = lp.id_liquidacao_previsao_pagamento", false);
		//$Select->where("l.id not in(SELECT id_liquidacao FROM sinistro.liquidacoes_pagamentos)");
		$Select->group(array("l.id"));
		$Select->where("l.id_processo = $id_processo");

		return $this->fetchAll($Select);
	}

	public function deleteItemSeguradoCobertura($idLiquidacao, $idItemSegurado) {
		$ModelLiquidacaoItensSeguradosCoberturas = new Sinistro2_Model_LiquidacoesItensSeguradosCoberturas();
		$ModelLiquidacaoItensSeguradosCoberturasLf = new Sinistro2_Model_LiquidacoesItensSeguradosCoberturasLF();
		$ModelLiquidacaoItensSeguradosCoberturasLfDependente = new Sinistro2_Model_LiquidacoesItensSeguradosCoberturasLFDependentes();

		$Item = $ModelLiquidacaoItensSeguradosCoberturas->getDefaultAdapter()->fetchOne("SELECT id FROM sinistro.liquidacoes_itens_segurados_coberturas WHERE id_liquidacao = " . $idLiquidacao . " AND id_item_segurado = " . $idItemSegurado);

		$ModelLiquidacaoItensSeguradosCoberturasLfDependente->delete($Item, "id_liquidacoes_itens_segurados_coberturas");
		$ModelLiquidacaoItensSeguradosCoberturasLf->delete($Item, "id_liquidacoes_itens_segurados_coberturas");

		return $ModelLiquidacaoItensSeguradosCoberturas->delete($Item);
	}

	public function saveArquivoLiquidacao($arquivo, $idLiquidacao) {
		$Row = $this->getRow($idLiquidacao);
		$Row->ds_arquivo_liquidacao_manual = $arquivo;

		return $Row->save();
	}

	public function getArquivosBeneficiario($idLiquidacao) {

		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array("l" => "sinistro.liquidacoes"), ['id_processo']);
		$Select->joinInner(array("p" => "sinistro.processos"), "l.id_processo = p.id", false);
		$Select->joinInner(array("pb" => "seguro.propostas_beneficiarios"), "pb.id_proposta = p.id_proposta", false);
		$Select->joinInner(array("b" => "seguro.beneficiarios"), "b.cpf_cnpj = pb.nr_cpf_cnpj", false);
		$Select->joinInner(array("ba" => "seguro.beneficiarios_arquivos"), "ba.id_beneficiario = b.id", array('id', 'ds_nome_arquivo', 'id_beneficiario'));
		$Select->where("l.id = ?", $idLiquidacao);
		$Select->where("b.id_status_arquivos = 108");
		$Select->where("ba.fl_ativo = true");

		return $this->fetchAll($Select)->toArray();
	}

	public function getArquivoLiquidacao($idLiquidacao) {

		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array("l" => "sinistro.liquidacoes"), array('id', 'ds_arquivo_liquidacao_manual'));
		$Select->where("l.id = $idLiquidacao");

		return $this->fetchAll($Select)->toArray();
	}

	public function deleteArquivoLiquidacao($idLiquidacao) {
		$update = "UPDATE sinistro.liquidacoes SET ds_arquivo_liquidacao_manual = null WHERE id='" . $idLiquidacao . "'";

		return $this->_db->query($update);
	}

	public function savePagamento($dados) {
		$Row = $this->getRow($dados['id_liquidacao']);
		$Row->dt_pagamento = Agro_Util::formatDate($dados['dt_pagamento'], Zend_Date::W3C);
		$Row->vl_pagamento = Agro_Util::formatCurrencyDb($dados['vl_pagamento']);
		$Row->dt_confirmacao_pagamento = $dados['dt_confirmacao_pagamento'] ? Agro_Util::formatDate($dados['dt_confirmacao_pagamento'], Zend_Date::W3C) : null;

		return $Row->save();
	}

	public function getDadosPagto($idLiquidacao) {
		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array("l" => "sinistro.liquidacoes"), array('dt_pagamento', 'vl_pagamento', 'dt_confirmacao_pagamento'));
		$Select->where("l.id = $idLiquidacao");

		return $this->_db->fetchRow($Select);
	}

	/**
	 * @name getCoberturasLiqManual
	 * @desc No caso da cobertura passada como parâmetro ser a cobertura principal
	 * 		 retorna todas as coberturas que tiverem o mesmo tipo de liquidação dela
	 *       ou não forem exibidas na regulação de perda. Caso contrario retorna a
	 *       cobertura passada pois de acordo com as regras, esta deve possuir uma
	 *       liquidação individual.
	 * @param $id_proposta
	 * @param $id_cobertura
	 * @author Vinicius Berni
	 * @since 13/07/2011
	 */
	public function getCoberturasLiqManual($id_proposta, $id_cobertura) {
		$ModelProposta = new Seguro_Model_Propostas();
		$ModelProdutoCobertura = new Produto_Model_ProdutosCoberturas();

		$Proposta = $ModelProposta->find($id_proposta)->current();
		$ProdutoCobertura = $ModelProdutoCobertura->find($Proposta->id_produto, $id_cobertura)->current();

		if ($ProdutoCobertura->fl_cobertura_principal) {
			$sql = "
				select
					c.id as id_cobertura,
					c.ds_nome_cobertura
				from
					seguro.propostas p inner join
				    produto.produtos_coberturas pc on pc.id_produto = p.id_produto inner join
				    produto.coberturas c on c.id = pc.id_cobertura
				where
					p.id = $id_proposta and
				    (
				       (pc.id_tipo_liquidacao in (
				       		select
				            	prc.id_tipo_liquidacao
				            from
				            	produto.produtos_coberturas  prc
				            where
				               prc.id_produto = p.id_produto and
				               prc.fl_cobertura_principal = TRUE
				            )
				       ) or (
				       		pc.fl_exibir_regulacao_perdas = FALSE
				       ) or (
				        	pc.id_tipo_liquidacao is null and pc.fl_exibir_regulacao_perdas = TRUE
				        )
				    ) and (
				    	pc.id_cobertura in (
				    		select prc.id_cobertura from seguro.propostas_coberturas prc where prc.id_proposta = $id_proposta
				    	)
				    )
				order by
					pc.fl_cobertura_principal desc,
				    c.ds_nome_cobertura
			";
		} else {
			$sql = "
				select
					c.id as id_cobertura,
					c.ds_nome_cobertura
				from
				    produto.coberturas c
				where
					c.id = $id_cobertura and
				    c.id in (
				    		select prc.id_cobertura from seguro.propostas_coberturas prc where prc.id_proposta = $id_proposta
				  	);
			";
		}

		return $this->_db->fetchAll($sql);
	}

	public function getItensLiquidacaoManual(int $id_proposta, int $id_processo, int $id_cobertura)
    {
        $modelLaudosFinais = new Sinistro2_Model_LaudosFinais();

        $select = $this->select()->setIntegrityCheck(false)->distinct(true);
        $select->from(
            array("iseg" => "seguro.itens_segurados"),
            array(
                "iseg.id_proposta",
                "iseg.id as id_item_segurado",
                "iseg.nr_item_segurado",
                "iseg.ds_item_segurado",
                "iseg.vl_area",
                "iseg.vl_lmga"
            )
        );
        $select->joinInner(array("v" => "produto.variedades"), "v.id = iseg.id_variedade", "v.ds_nome_variedade");
        $select->joinInner(array("pc" => "seguro.propostas_coberturas"), "pc.id_proposta = iseg.id_proposta", false);
        $select->where("iseg.id_proposta = ?", $id_proposta);
        $select->where("pc.id_cobertura = ?", $id_cobertura);
        $select->order("iseg.nr_item_segurado asc");

        $row = $this->fetchAll($select);
        $result = array();

        if ($row) {
            $itens = $row->toArray();

            foreach ($itens as $iten) {
                if (
                    $modelLaudosFinais->naoExisteLiquidacaoAnterior(
                        $id_processo,
                        $iten['id_item_segurado'],
                        $id_cobertura
                    )
                ) {
                    $iten["COBERTURAS"] = $this->getCoberturasLiqManual($id_proposta, $id_cobertura);
                    $result[] = $iten;
                }
            }
        }
        return $result;
    }

	public function getPagamentosByProcesso($idProcesso, $idLiquidacao=null){
		$Select = $this->select()->setIntegrityCheck(false);
		$Select->from(array('p' => 'sinistro.processos'), 'id as id_processo', false);
		$Select->join(array('l' => 'sinistro.liquidacoes'), 'l.id_processo = p.id', 'l.id as id_liquidacao');
		$Select->join(array('tl' => 'sinistro.tipo_liquidacao'), 'tl.id = l.id_tipo_liquidacao', 'tl.ds_chave as tipo_liquidacao');
		$Select->join(array('lpp' => 'sinistro.liquidacoes_previsao_pagamento'), 'lpp.id_liquidacao = l.id', 
			array(
				'lpp.id as id_pagamento', 
				'lpp.vl_pagamento', 
				'lpp.dt_pagamento', 
				'lpp.dt_confirmacao_pagamento', 
				'lpp.dt_alteracao', 
				'lpp.id_usuario_criacao',
				'lpp.id_recibo_seguradora',
				'lpp.id_pagamento_seguradora',
				'lpp.id_documento_liquidacao',
				'lpp.fl_pagamento_adicional'
			)
		);
		$Select->joinLeft(array('pa'=>'sinistro.processos_arquivos'), 'pa.id = lpp.id_arquivo_processo', array('ds_nome_arquivo', 'id as id_arquivo'));
		$Select->joinLeft(array('pd'=>'sinistro.processos_arquivos'), 'pd.id = lpp.id_documento_liquidacao', array('ds_nome_arquivo as ds_nome_documento', 'id as id_documento'));
		$Select->where('p.id = ?', $idProcesso);
		$Select->order('l.id ASC, lpp.id_recibo_seguradora ASC, pa.id ASC, pd.id ASC');

		if (!is_null($idLiquidacao)) {
			$Select->where('l.id = ?', $idLiquidacao);
		}

		//$Select->group(array('p.id', 'id_pagamento', 'lpp.vl_pagamento', 'lpp.vl_pagamento', 'lpp.dt_confirmacao_pagamento', 'lpp.dt_alteracao', 'lpp.id_usuario_criacao', 'pa.ds_nome_arquivo', 'pa.id'));
		
		return $this->_db->fetchAll($Select);

	}

	public function getItensLaudoMultirisco($idLiquidacao) {
	    $Select = $this->select()->setIntegrityCheck(false);
	    $Select->from(array('sis' => 'seguro.itens_segurados'), array('vl_area','vl_rendimento_tonelada','vl_lmga'),false);
	    $Select->join(array('lfis' => 'sinistro.laudos_finais_itens_segurados'),'sis.id = lfis.id_item_segurado', array('vl_percent_colhido','vl_rendimento_final_lavoura'));
		$Select->join(array('lisclf' => 'sinistro.liquidacoes_itens_segurados_coberturas_lf'), 'lfis.id = lisclf.id_laudo_final_item_segurado', false);
		$Select->join(array('lisc' => 'sinistro.liquidacoes_itens_segurados_coberturas'), 'lisclf.id_liquidacoes_itens_segurados_coberturas = lisc.id', false);
	    $Select->join(array('isc' => 'seguro.itens_segurados_complemento'), 'sis.id = isc.id_item_segurado', 'vl_producao_garantida');
	    $Select->join(array('lf' => 'sinistro.laudos_finais'), 'lf.id = lfis.id_laudo_final', false);
	    $Select->where('lisc.id_liquidacao = ?', $idLiquidacao);
	    $Select->where('lfis.id_motivo_quadra_nao_vistoriada IS NULL OR lfis.id_motivo_quadra_nao_vistoriada IN (1,2,3,4,7)');
	    $Select->where('lf.id_status <> 207');

	    return $this->_db->fetchAll($Select);
    }

    public function getPagamentosCoberturasBeneficiario($idProcesso)
    {
        $coberturasIgnorar = $coberturasInvalidasBeneficiario = [
          Produto_Model_Coberturas::COB_PROTECAO_FITO,
          Produto_Model_Coberturas::COB_QUEDA_PARREIRAL,
          Produto_Model_Coberturas::COB_REPLANTIO,
          Produto_Model_Coberturas::COB_REPLANTIO_SEM_ESTIAGEM,
          Produto_Model_Coberturas::COB_REPLANTIO_EXCESSO_CHUVA,
          Produto_Model_Coberturas::COB_REPLANTIO_GEADA
        ];

        $coberturasIgnorar = implode(', ', $coberturasIgnorar);

        $select = $this->select()->distinct(true)->setIntegrityCheck(false);
        $select->from(['p' => 'sinistro.processos'], 'id as id_processo', false);
        $select->join(['l'   => 'sinistro.liquidacoes'], 'l.id_processo = p.id', false);
        $select->join(['lic' => 'sinistro.liquidacoes_itens_segurados_coberturas'], 'lic.id_liquidacao = l.id', false);
        $select->join(['cob' => 'produto.coberturas'], 'cob.id = lic.id_cobertura', false);
        $select->join(['lpp' => 'sinistro.liquidacoes_previsao_pagamento'], 'lpp.id_liquidacao = l.id', ['lpp.vl_pagamento']);
        $select->where('p.id = ?', $idProcesso);
        $select->where("cob.id not in({$coberturasIgnorar})");
        $select->group(['p.id', 'lpp.vl_pagamento']);

        return $this->fetchAll($select)->toArray();
    }

    public function getTotalPagoLiquidacoesByProcesso(int $idProcesso)
    {
        $rowLiquidacoes = $this->getPagamentosCoberturasBeneficiario($idProcesso);
        $totalPago = 0;

        foreach ($rowLiquidacoes as $liquidacaoPaga) {
            $totalPago += $liquidacaoPaga['vl_pagamento'];
        }

        return number_format($totalPago, 2, '.', '');
    }

    /**
     * Cálculo executado quando a cobertura do tem tipo de liquidação LIQ17
     *
     * @param int $idLiquidacao
     * @return float|int
     */
    public function getValorIndenizacaoLiq17(int $idLiquidacao)
    {
        $soma_mpa = 0;
        $soma_pgm = 0;
        $soma_lmga = 0;
        $area_total = 0;

        $itens = $this->getItensLaudoMultirisco($idLiquidacao);

        foreach ($itens as $quadra) {
            $rendimento = round(((($quadra['vl_percent_colhido']/100) * $quadra['vl_area'] * $quadra['vl_rendimento_tonelada']) + ((1 - ($quadra['vl_percent_colhido']/100))
                  * $quadra['vl_area'] * $quadra['vl_rendimento_final_lavoura']))/$quadra['vl_area'], 3);

            $soma_mpa += $rendimento * $quadra['vl_area'];
            $soma_pgm += $quadra['vl_area'] * $quadra['vl_producao_garantida'];
            $soma_lmga += $quadra['vl_lmga'];
            $area_total += $quadra['vl_area'];
        }

        $pmo = ($soma_mpa / $area_total);
        $pgm = $soma_pgm / $area_total;
        $perc_indenizacao = round((($pgm - $pmo) / $pgm), 4);
        $perc_indenizacao = round($perc_indenizacao * 100, 2);
        $perc_indenizacao = $perc_indenizacao < 0 ? 0 : $perc_indenizacao;
        $valorIndenizacao = ($perc_indenizacao/100) * $soma_lmga;

        return $valorIndenizacao;
    }

	public function loadInformacaoCartaSemIndinizacao(
		int $idLiquidacao,
		array $idsAvisos = [],
		bool $ignoraQuedaParreiralReplantio = false,
		string $idsAvisosQuedaEventoGranizo = ''
	): array {
		$subqueryAvisos = $this->select()
			->setIntegrityCheck(false)
			->from(['sa' => 'sinistro.avisos'], 'sa.id_proposta, string_agg(id::text, \', \') AS id_aviso')
			->where('sa.id_status <>'. Sistema_Model_Status::AVISO_CANCELADO)
			->where('sa.id_status <>'. Sistema_Model_Status::AVISO_RECUSADO)
			->group('sa.id_proposta');
		
		$subqueryEventos = $this->select()
			->setIntegrityCheck(false)
			->from(['pe' => 'produto.eventos'], 'string_agg(ds_nome_evento::text, \', \') AS ds_nome_evento')
			->join(['sae' => 'sinistro.avisos_eventos'], 'sae.id_evento = pe.id', false)
			->join(['sa' => 'sinistro.avisos'], 'sa.id = sae.id_aviso', 'id_proposta')
			->where('sa.id_status <>'. Sistema_Model_Status::AVISO_CANCELADO)
			->where('sa.id_status <>'. Sistema_Model_Status::AVISO_RECUSADO)
			->group('id_proposta');
		
		if ($ignoraQuedaParreiralReplantio) {
			$condicao = '(
					sa.fl_ocorrencia_queda_parreiral IS NULL OR sa.fl_ocorrencia_queda_parreiral IS FALSE) 
					AND (fl_ocorrencia_replantio IS FALSE  OR fl_ocorrencia_replantio IS NULL
				)'
			;

			// Se for cobertura de queda e evento de granizo, deve trazer aviso na carta
			if ($idsAvisosQuedaEventoGranizo != '') {
				$condicao = '
					sa.id IN ('. $idsAvisosQuedaEventoGranizo .')
					OR (
						sa.fl_ocorrencia_queda_parreiral IS NULL OR sa.fl_ocorrencia_queda_parreiral IS FALSE) 
						AND (fl_ocorrencia_replantio IS FALSE  OR fl_ocorrencia_replantio IS NULL
					)
				';
			}

			$subqueryAvisos->where($condicao);
			$subqueryEventos->where($condicao);
		} else if (!empty($idsAvisos)) {
			$subqueryAvisos->where('sa.id IN (?)', $idsAvisos);
			$subqueryEventos->where('sa.id IN (?)', $idsAvisos);
		}
		
		$subqueryMotivoIndenizacao = $this->select()
				->setIntegrityCheck(false)
				->from(['slm' => 'sinistro.liquidacoes_motivos_liquidacao_sem_indenizacao'], 'id_liquidacao')
				->join(
					['sm' => 'sinistro.motivos_liquidacao_sem_indenizacao'],
					'sm.id = slm.id_motivos_liquidacao_sem_indenizacao',
					'string_agg(ds_motivo::TEXT, \', \') AS motivo, string_agg(sm.id::TEXT, \', \') AS id_motivo')
				->group('slm.id_liquidacao');

		$rs = $this->fetchRow(
			$this->select()
				->setIntegrityCheck(false)
				->from(['sl' => 'sinistro.liquidacoes'], 'id as id_liquidacao, id_processo')
				->join(['sp' => 'sinistro.processos'], 'sp.id = sl.id_processo', 'id_proposta')
				->join(['spr' => 'seguro.propostas'], 'spr.id = sp.id_proposta', 'nr_apolice')
				->joinLeft(['subev' => $subqueryEventos], 'subev.id_proposta = spr.id', 'ds_nome_evento')
				->join(['spp' => 'seguro.propostas_proponentes'], 'spp.id_proposta = spr.id', 'spp.ds_nome_proponente, spp.cpf_cnpj')
				->join(['spc' => 'seguro.propostas_corretores'], 'spc.id_proposta = spr.id', false)
				->join(['su' => 'sistema.usuarios'], 'su.id = spc.id_usuario', false)
				->join(['sc' => 'sistema.corretores'], 'sc.id_usuario = su.id', 'ds_nome_corretor as corretor')
				->joinLeft(['sls' => 'sinistro.liquidacoes_status'], 'sls.id_liquidacao = sl.id AND sls.fl_ativo IS TRUE', 'sls.dt_criacao')
				->joinLeft(['ss' => 'sistema.status'], 'ss.id = sls.id_status', 'ds_status')
				->joinLeft(
					['sublm' => $subqueryMotivoIndenizacao],
					'sublm.id_liquidacao = sl.id', 'sublm.motivo AS motivos_sem_indenizacao, sublm.id_motivo AS ids_motivos_sem_indenizacao')
				->joinLeft(['sa' => $subqueryAvisos], 'sa.id_proposta = spr.id', 'id_aviso')
				->joinLeft(
					['sce' => 'sistema.corretores_enderecos'],
					'sce.id_corretor = sc.id',
					'sce.ds_endereco_rua, sce.ds_endereco_nro, sce.ds_endereco_complemento, sce.ds_endereco_bairro, sce.ds_endereco_cep')
				->joinLeft(['smun' => 'sistema.municipios'], 'smun.id = sce.id_municipio', 'smun.ds_nome_municipio')
				->joinLeft(['se' => 'sistema.estados'], 'se.id = smun.id_estado', 'se.ds_sigla')
				->where('sl.id = ?', $idLiquidacao)
		);
		
		$result = [];

		if ($rs) {
			$result = $rs->toArray();
		}
		
		return $result;
	}

	public function getValorTotalIndenizacao(int $idLiquidacao): float
	{
		$row = $this->_db->fetchRow(
			$this->select()
				->setIntegrityCheck(false)
				->from(['l' => 'sinistro.liquidacoes'], false)
				->join(
					['lisc' => 'sinistro.liquidacoes_itens_segurados_coberturas'],
					'lisc.id_liquidacao = l.id',
					'SUM(GREATEST(lisc.vl_indenizacao, 0)) AS vl_total_indenizacao'
				)
				->join(['c' => 'produto.coberturas'], 'c.id = lisc.id_cobertura', false)
				->join(["ise" => "seguro.itens_segurados"], "ise.id = lisc.id_item_segurado", false)
				->where('l.id = ?', $idLiquidacao)
		);

		if (!empty($row)) {
			return (float) $row['vl_total_indenizacao'];
		}
		
		return 0;
	}
}