<?php

namespace App\DAO;

use App\DAO\DAO;
use App\DAO\DAOResponse\DAOResponse;
use App\DAO\DAOResponse\DAOResponseInterface;
use App\ViewModels\Anamnese\AnamneseAdicionalRegistrationViewModel\AnamneseAdicionalRegistrationViewModel;
use App\ViewModels\Orcamento\OrcamentoClienteItemDetalhe\OrcamentoClienteItemDetalhe;
use App\Services\ConvenioProcedimentoService;
use App\Services\ServiceResponse\ServiceResponseInterface;
use App\Services\JWT\UsuarioLogado;
use App\Utils\DateUtils;
use App\Services\AssistenteService;
use App\Services\TipoProcedimentoService;
use Exception;

class RequisicaoDAO extends DAO {

	public function registerRequisicaoATDContinuado(AnamneseAdicionalRegistrationViewModel $objRegister): DAOResponse {

		$dao_response = new DAOResponse();

		$sql = <<<SQL
			insert into requisicao_procedimento 
				(id_medico,id_pet, id_convenio_procedimento, status_id, data_requisicao,hora_requisicao,status_anamnese) 
			values
				(:medico_id:,:pet_id:, :cp_id:, :statusid:, :data_req:, :hora_req:, 0)
		SQL;

		$binds = [ 
			'medico_id' => $objRegister->getIdMedico(),
			'pet_id' => $objRegister->getIdPet(),
			'cp_id' => $objRegister->getIdConvenioProcedimento(),
			'statusid' => REQUISICAO_STATUS_CRIADO_ATD_CONTIUADO,
			'data_req' => $objRegister->getDataCriacao(),
			'hora_req' => $objRegister->getHoraCriacao()
		];
		$conn = db_connect();
		$result = $conn->query( $sql, $binds )->numRows;
		$errors = $conn->error();

		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
		} else {
			$newId = $conn->insertID();
			$dao_response->setData( [ 
				'id_requisicao' => $newId
			] );
			$dao_response->setStatus( DAOResponseInterface::SUCESS );
		}

		return $dao_response;

	}

	public function registerRequisicaoEXContinuado(AnamneseAdicionalRegistrationViewModel $objRegister): DAOResponse {

		$dao_response = new DAOResponse();

		$sql = <<<SQL
			insert into requisicao_procedimento
				(id_pet, id_convenio_procedimento, status_id,usuario_executor, data_requisicao,hora_requisicao,status_anamnese)
			values
				(:pet_id:, :cp_id:, :statusid:, :usr_id: ,:data_req:, :hora_req:, 0)
		SQL;

		$binds = [ 
			'medico_id' => $objRegister->getIdMedico(),
			'pet_id' => $objRegister->getIdPet(),
			'cp_id' => $objRegister->getIdConvenioProcedimento(),
			'statusid' => REQUISICAO_STATUS_CRIADO_ATD_CONTIUADO,
			'usr_id' => UsuarioLogado::getUsuarioId(),
			'data_req' => $objRegister->getDataCriacao(),
			'hora_req' => $objRegister->getHoraCriacao()
		];
		$conn = db_connect();
		$result = $conn->query( $sql, $binds )->numRows;
		$errors = $conn->error();

		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
		} else {
			$newId = $conn->insertID();
			$dao_response->setData( [ 
				'id_requisicao' => $newId
			] );
			$dao_response->setStatus( DAOResponseInterface::SUCESS );
		}

		return $dao_response;

	}

	public function updateRequisicaoATDContinuado(): DAOResponse {

		$dao_response = new DAOResponse();

		$sql = <<<SQL
		SQL;

		$binds = [ ];
		$conn = db_connect();
		$result = $conn->query( $sql, $binds )->numRows;
		$errors = $conn->error();

		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
		} else {
			$affected = $conn->affectedRows();
			$dao_response->setData( [ 
				'registros' => $affected
			] );
			$dao_response->setStatus( DAOResponseInterface::SUCESS );
		}

		return $dao_response;

	}

	public function getStatusRequisicaoById(int $idRequisicao): DAOResponse {

		$dao_response = new DAOResponse();

		$sql = <<<SQL
			select status_id from requisicao_procedimento rp where rp.id  = :requisicao_id: 
		SQL;

		$binds = [ 
			'requisicao_id' => $idRequisicao
		];
		$conn = db_connect();
		$result = $conn->query( $sql, $binds )
			->getResultArray();
		$errors = $conn->error();

		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
		} else {

			$dao_response->setData( [ 
				'id_status' => $result [0] ['status_id']
			] );
			$dao_response->setStatus( DAOResponseInterface::SUCESS );
		}

		return $dao_response;

	}

	public function getRequisicoesEmAbertoByPetIdByUnidadeToAtender(int $pet_id, int $unidade_id): DAOResponse {

		$dao_response = new DAOResponse();

		$sql = <<<SQL
			select * 
			from ( select rp.id, ci.comanda_item_status_id , un.descricao as unidade, rp.id_pet, 
						pe.nome as pet_nome , pc.id_cliente , pf.nome as tutor,
						rp.id_convenio_procedimento, rp.status_id, rps.descricao  as descricao_status, 
						rp.data_requisicao,	rp.hora_requisicao, p.id as procedimento_id, p.descricao as procedimento, 
						tp.id as tipo_procedimento_id,	tp.descricao as tipo_procedimento, tc.id id_tipo_convenio,
						tc.descricao as convenio_tipo,
						CASE
							when ((ci.comanda_item_status_id <= 2) and (tc.id >= 1) and (rp.status_id = 1)) then '1'
							when ((ci.comanda_item_status_id is null) and (tc.id >= 1) and (rp.status_id = 4) ) then '1'
							when ((ci.comanda_item_status_id is null) and (tc.id >= 1)) then '1'
							ELSE '0'
						END as atender
					from
						pet pe, pet_cliente pc , cliente cl, pessoa_fisica pf,requisicao_procedimento_status rps,
						convenio_procedimento cp, unidade un, procedimento p, tipo_procedimento tp, convenio c, tipo_convenio tc,
						requisicao_procedimento rp Left join comanda_item as ci on ci.id_requisicao_procedimento  = rp.id
					where
						rp.id_pet = :id_pet:
						and rp.data_requisicao >= DATE_ADD(CURDATE(), INTERVAL -30 DAY)
						and rp.id_pet = pe.id 
						and pe.id = pc.id_pet
						and pc.id_cliente = cl.id 
						and cl.id_pessoa = pf.id_pessoa
						and rp.status_id in ( 1,4 )
						and rp.status_id = rps.id
						and rp.id_convenio_procedimento = cp.id
						and cp.id_unidade = :id_unidade:
						and un.id = cp.id_unidade
						and cp.id_convenio = c.id
						and c.id_tipo_convenio = tc.id
						and cp.id_procedimento = p.id
						and p.id_tipo_procedimento = tp.id ) tb
			where tb.atender = 1
			order by tb.data_requisicao desc
		SQL;

		$binds = [ 
			'id_pet' => $pet_id,
			'id_unidade' => $unidade_id,
			'status_list' => REQUISICAO_STATUS_CRIADO . ', ' . REQUISICAO_STATUS_CRIADO_ATD_CONTIUADO
		];
		$conn = db_connect();
		$result = $conn->query( $sql, $binds )
			->getResultArray();
		$errors = $conn->error();

		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
		} else {
			if (count( $result ) == 0) {
				$dao_response->setData( [ ] );
				$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
			} else {
				$dao_response->setStatus( DAOResponseInterface::SUCESS );
				$dao_response->setData( $result );
			}
		}

		return $dao_response;

	}

	public function getRequisicoesExamesEmAbertoByPetIdUnidadeId(int $idPet, int $idUnidade): DAOResponse {

		$dao_response = new DAOResponse();

		$sql = <<<SQL
			select
				rp.id , cp.id as convenio_prodecimento, rp.status_id , p.descricao as procedimento , 
				tc.descricao tipo_convenio, rp.id_requisitante , c.descricao as convenio,
				(select pf.nome from usuario u, pessoa_fisica pf 
					where u.id = rp.id_requisitante and u.id_pessoa = pf.id_pessoa
				) as nome
			from
				requisicao_procedimento rp, convenio_procedimento cp,
				convenio c , tipo_convenio tc , procedimento p
			where
				rp.id_pet = :pet_id:
				and rp.status_id = 1
				and rp.id_convenio_procedimento = cp.id
				and cp.id_unidade = :unidade_id:
				and cp.id_convenio = c.id
				and c.id_tipo_convenio = tc.id
				and cp.id_procedimento = p.id
				and p.id_tipo_procedimento = 4
		SQL;

		$binds = [ 
			'pet_id' => $idPet,
			'unidade_id' => $idUnidade
		];

		$conn = db_connect();
		$result = $conn->query( $sql, $binds )
			->getResultArray();
		$errors = $conn->error();

		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
		} else {
			if (count( $result ) == 0) {
				$dao_response->setData( [ ] );
				$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
			} else {
				$dao_response->setStatus( DAOResponseInterface::SUCESS );
				$dao_response->setData( $result );
			}
		}

		return $dao_response;

	}
	
	public function getRequisicoesHigieneEmAbertoByPetIdUnidadeId(int $idPet, int $idUnidade, $status_comanda): DAOResponse {
	    
	    $dao_response = new DAOResponse();
	    
	    $sql = <<<SQL
			SELECT
			    rp.id AS requisicao_procedimento_id,
			    rp.status_id AS status_id,
			    rp.data_requisicao AS data_requisicao,
			    rp.hora_requisicao AS hora_requisicao,rp.hora_execucao AS hora_execucao,rp.status_anamnese AS status_anamnese,
			    rp.id_consulta_exame AS id_consulta_exame,
			    pr.id AS procedimento_ide,
			    pr.descricao AS procedimento_descricao,
			    tp.id AS tipo_procedimento_id,
			    tp.descricao AS tipo_procedimento_descricao,
			    cnv.id AS convenio_id,
			    cnv.codigo AS convenio_codigo,
			    cnv.descricao AS convenio_descricao,
			    tc.id AS tipo_convenio_id,
			    tc.descricao AS tipo_convenio_descricao,
			    rp.id_pet AS pet_id, (select pf.nome from usuario u, pessoa_fisica pf 
					where u.id = rp.id_requisitante and u.id_pessoa = pf.id_pessoa
				) as nome
			FROM requisicao_procedimento rp
			    JOIN convenio_procedimento cp ON cp.id = rp.id_convenio_procedimento
			    JOIN convenio cnv ON cp.id_convenio = cnv.id
			    JOIN tipo_convenio tc ON cnv.id_tipo_convenio = tc.id
			    JOIN pet pe ON rp.id_pet = pe.id
			    JOIN pet_cliente pc ON rp.id_pet = pc.id_pet
			    JOIN cliente c ON pc.id_cliente = c.id
			    JOIN pessoa_fisica pf ON c.id_pessoa = pf.id_pessoa
			    JOIN procedimento pr ON cp.id_procedimento = pr.id
			    JOIN tipo_procedimento tp ON pr.id_tipo_procedimento = tp.id
			    JOIN comanda_item ci ON ci.id_requisicao_procedimento = rp.id
			WHERE cp.id_unidade = :unidade_id:
			  AND rp.status_id = 1
			  AND tp.id = 9
			  AND rp.id_pet = :pet_id:
		SQL;
	    
	    $binds = [
	        'pet_id' => $idPet,
	        'unidade_id' => $idUnidade
	    ];
	    
	    if (!is_null($status_comanda) && $status_comanda == 2) {
	        // Adicione o filtro no SQL e adicione o parâmetro no array de binds
	        $sql .= ' AND ci.comanda_item_status_id = :comandaid:';
	        $binds['comandaid'] = 2;
	    }
	    
	    $conn = db_connect();
	    $result = $conn->query( $sql, $binds )
	    ->getResultArray();
	    $errors = $conn->error();
	    
	    if ($errors ['code'] != 0) {
	        $dao_response->setErrors( $errors );
	        $dao_response->setData( [ ] );
	        $dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
	    } else {
	        if (count( $result ) == 0) {
	            $dao_response->setData( [ ] );
	            $dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
	        } else {
	            $dao_response->setStatus( DAOResponseInterface::SUCESS );
	            $dao_response->setData( $result );
	        }
	    }
	    
	    return $dao_response;
	    
	}

	public function setItemExtornadoToExcluirRequisicao($itemExtornado): DAOResponse {

		$dao_response = new DAOResponse();

		$sql_rp_id = <<<SQL
			select id_requisicao_procedimento  from comanda_item ci where ci.id = :item_id:
		SQL;
		$binds_rp_id = [ 
			'item_id' => $itemExtornado->comanda_item_id
		];

		$conn_rp = db_connect();
		$result_rp = $conn_rp->query( $sql_rp_id, $binds_rp_id )
			->getResultArray();
		$errors_rp = $conn_rp->error();

		if ($errors_rp ['code'] != 0) {
			$dao_response->setErrors( $errors_rp );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
			return $dao_response;
		}

		$idReq = $result_rp [0] ['id_requisicao_procedimento'];

		$usr = UsuarioLogado::getUsuarioId();
		$data_atz = DateUtils::today();
		$hora_atz = DateUtils::now_time();

		$sql = <<<SQL
			update requisicao_procedimento
				set status_id = 3,
					atualizado_por = :usuario_id:,
					data_atualizacao = :data_atz:,
					hora_atualizacao = :hora_atz:
			where
				id = :requisicao_id:					
				and status_id = 1
		SQL;

		$binds = [ 
			'usuario_id' => $usr,
			'requisicao_id' => $idReq,
			'data_atz' => $data_atz,
			'hora_atz' => $hora_atz
		];

		$conn = db_connect();
		$conn->query( $sql, $binds )->numRows;
		$errors = $conn->error();

		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
		} else {
			$affect = $conn->affectedRows();
			if ($affect > 0) {
				$dao_response->setData( [ ] );
				$dao_response->setStatus( DAOResponseInterface::SUCESS );
			} else {
				$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
				$dao_response->setData( [ ] );
			}
		}

		return $dao_response;

	}

	public function isExecutedItemComanda(int $idItem): DAOResponse {

		$dao_response = new DAOResponse();

		$sql = <<<SQL
					select 
						ci.id as comada_item, rp.id as req_id, rp.status_id 
					from 
						comanda_item ci , requisicao_procedimento rp 
					where 
						ci.id = :item_id:
						and ci.id_requisicao_procedimento  = rp.id 
		SQL;
		$bind = [ 
			'item_id' => $idItem
		];

		$conn = db_connect();
		$result = $conn->query( $sql, $bind )
			->getResultArray();
		$errors = $conn->error();

		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
			return $dao_response;
		}
		if (count( $result ) > 0) {
			$dao_response->setData( $result );
			$dao_response->setStatus( DAOResponseInterface::SUCESS );
		} else {
			$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
			$dao_response->setData( [ ] );
		}

		return $dao_response;

	}

	public function adminExecExame(int $requisicao_id, int $assistente_id, string $data_exec, string $hora_exec): DAOResponse {

		$assistenteService = new AssistenteService();
		$assistente_response = $assistenteService->getUsuarioIDFromAssitenteID( $assistente_id );

		$dao_response = new DAOResponse();

		if ($assistente_response->getStatus() == ServiceResponseInterface::RECORD_NOT_FOUND) {
			$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
			return $dao_response;
		}

		if ($assistente_response->getStatus() != ServiceResponseInterface::SUCESS) {
			$dao_response->setStatus( $assistente_response->getStatus() );
			$dao_response->setErrors( $assistente_response->getErrors() );
			return $dao_response;
		}

		$tpService = new TipoProcedimentoService();
		$tpService_response = $tpService->getTipoProcedimentoByRequisicaoId( $requisicao_id );

		if ($tpService_response->getStatus() == ServiceResponseInterface::RECORD_NOT_FOUND) {
			$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
			return $dao_response;
		}

		if ($tpService_response->getStatus() != ServiceResponseInterface::SUCESS) {
			$dao_response->setStatus( $tpService_response->getStatus() );
			$dao_response->setErrors( $tpService_response->getErrors() );
			return $dao_response;
		}

		$tprocedimento = $tpService_response->getData();
		$objProcedimento = $tprocedimento [0];
		if (intval( $objProcedimento ['id_tipo_procedimento'] != 4 ) && intval( $objProcedimento ['id_tipo_procedimento'] != 5 )) {
			$dao_response->setStatus( DAOResponseInterface::INSUFFICIENT_DATA );
			return $dao_response;
		}
		$usr = $assistente_response->getData();
		$usr_exec = $usr [0] ['id'];
		$usrLogado = UsuarioLogado::getUsuarioId();
		$data_atz = DateUtils::today();
		$hora_atz = DateUtils::now_time();

		$sql = <<<SQL
			update 
					requisicao_procedimento rp
				set 
					rp.status_id = 2 , rp.usuario_executor = :user_exec_id: , 
				    rp.data_execucao = :data_exec:, rp.hora_execucao = :hora_exec:,
					rp.atualizado_por = :id_usuario: , 
					rp.data_atualizacao = :data_atz: ,rp.hora_atualizacao = :hora_atz:
				where
					rp.id = :id_requisicao:
					and rp.status_id = 1
		 
		SQL;

		$binds = [ 
			'id_requisicao' => $requisicao_id,
			'user_exec_id' => $usr_exec,
			'data_exec' => $data_exec,
			'hora_exec' => $hora_exec,
			'id_usuario' => $usrLogado,
			'data_atz' => $data_atz,
			'hora_atz' => $hora_atz
		];
		$conn = db_connect();
		$numrows = $conn->query( $sql, $binds )->numRows;
		$errors = $conn->error();

		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
			return $dao_response;
		}
		$affectRows = $conn->affectedRows();
		if ($affectRows > 0) {
			$dao_response->setStatus( DAOResponseInterface::SUCESS );
		} else {
			$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
			$dao_response->setData( [ ] );
		}

		return $dao_response;

	}

	public function adminExcluirExame(int $requisicao_id): DAOResponse {

		$dao_response = new DAOResponse();

		$tpService = new TipoProcedimentoService();
		$tpService_response = $tpService->getTipoProcedimentoByRequisicaoId( $requisicao_id );

		if ($tpService_response->getStatus() == ServiceResponseInterface::RECORD_NOT_FOUND) {
			$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
			return $dao_response;
		}

		if ($tpService_response->getStatus() != ServiceResponseInterface::SUCESS) {
			$dao_response->setStatus( $tpService_response->getStatus() );
			$dao_response->setErrors( $tpService_response->getErrors() );
			return $dao_response;
		}

		$tprocedimento = $tpService_response->getData();
		$objProcedimento = $tprocedimento [0];
		if (intval( $objProcedimento ['id_tipo_procedimento'] != 4 ) && intval( $objProcedimento ['id_tipo_procedimento'] != 5 )) {
			$dao_response->setStatus( DAOResponseInterface::INSUFFICIENT_DATA );
			return $dao_response;
		}

		$usr_exec = $usr [0] ['id'];
		$usrLogado = UsuarioLogado::getUsuarioId();
		$data_atz = DateUtils::today();
		$hora_atz = DateUtils::now_time();

		$sql = <<<SQL
			update
					requisicao_procedimento rp
				set
					rp.status_id = 3 , 
					rp.atualizado_por = :id_usuario: ,
					rp.data_atualizacao = :data_atz: ,rp.hora_atualizacao = :hora_atz:
				where
					rp.id = :id_requisicao:
					and rp.status_id = 1
					
		SQL;

		$binds = [ 
			'id_requisicao' => $requisicao_id,
			'id_usuario' => $usrLogado,
			'data_atz' => $data_atz,
			'hora_atz' => $hora_atz
		];
		$conn = db_connect();
		$numrows = $conn->query( $sql, $binds )->numRows;
		$errors = $conn->error();

		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
			return $dao_response;
		}
		$affectRows = $conn->affectedRows();
		if ($affectRows > 0) {
			$dao_response->setStatus( DAOResponseInterface::SUCESS );
		} else {
			$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
			$dao_response->setData( [ ] );
		}

		return $dao_response;

	}
	
	public function adminExcluirConsulta(int $requisicao_id): DAOResponse {
		
		$dao_response = new DAOResponse();
		
		$tpService = new TipoProcedimentoService();
		$tpService_response = $tpService->getTipoProcedimentoByRequisicaoId( $requisicao_id );
		
		if ($tpService_response->getStatus() == ServiceResponseInterface::RECORD_NOT_FOUND) {
			$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
			return $dao_response;
		}
		
		if ($tpService_response->getStatus() != ServiceResponseInterface::SUCESS) {
			$dao_response->setStatus( $tpService_response->getStatus() );
			$dao_response->setErrors( $tpService_response->getErrors() );
			return $dao_response;
		}
		
		$tprocedimento = $tpService_response->getData();
		$objProcedimento = $tprocedimento [0];
		if (intval( $objProcedimento ['id_tipo_procedimento'] != 2 ) && intval( $objProcedimento ['id_tipo_procedimento'] != 3 )) {
			$dao_response->setStatus( DAOResponseInterface::INSUFFICIENT_DATA );
			return $dao_response;
		}
		
		$usr_exec = $usr [0] ['id'];
		$usrLogado = UsuarioLogado::getUsuarioId();
		$data_atz = DateUtils::today();
		$hora_atz = DateUtils::now_time();
		
		$sql = <<<SQL
			update
					requisicao_procedimento rp
				set
					rp.status_id = 3 ,
					rp.atualizado_por = :id_usuario: ,
					rp.data_atualizacao = :data_atz: ,rp.hora_atualizacao = :hora_atz:
				where
					rp.id = :id_requisicao:
					and rp.status_id = 1
					
		SQL;
		
		$binds = [
				'id_requisicao' => $requisicao_id,
				'id_usuario' => $usrLogado,
				'data_atz' => $data_atz,
				'hora_atz' => $hora_atz
		];
		$conn = db_connect();
		$numrows = $conn->query( $sql, $binds )->numRows;
		$errors = $conn->error();
		
		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
			return $dao_response;
		}
		$affectRows = $conn->affectedRows();
		if ($affectRows > 0) {
			$dao_response->setStatus( DAOResponseInterface::SUCESS );
		} else {
			$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
			$dao_response->setData( [ ] );
		}
		
		return $dao_response;
		
	}

	public function adminNewReqExame(array $request): DAOResponse {

		$dao_response = new DAOResponse();
		$idPet = $request ['id_pet'];
		$idCliente = $request ['id_cliente'];
		$idAssistente = $request ['assistente_id'];
		$idUnidade = $request ['id_unidade'];
		$idConvenioProcedimento = $request ['id_convenio_procedimento'];
		try {
			$idPet = intval( $request ['id_pet'] );
			$idCliente = intval( $request ['id_cliente'] );
			$idAssistente = intval( $request ['assistente_id'] );
			$idUnidade = intval( $request ['id_unidade'] );
			$idConvenioProcedimento = intval( $request ['id_convenio_procedimento'] );
		} catch ( Exception $e ) {
			$dao_response->setErrors( $e->getMessage() );
			$dao_response->setStatus( DAOResponseInterface::INSUFFICIENT_DATA );
			return $dao_response;
		}

		$dataExec = $request ['data_exec'];
		$horaExec = $request ['hora_exec'];

		$assistenteService = new AssistenteService();
		$assistente_response = $assistenteService->getUsuarioIDFromAssitenteID( $idAssistente );

		if ($assistente_response->getStatus() != ServiceResponseInterface::SUCESS) {
			$dao_response->setErrors( $assistente_response->getErrors() );
			$dao_response->setStatus( $assistente_response->getStatus() );
			return $dao_response;
		}

		$assistente_response_data = $assistente_response->getData();
		$usr_exec = $assistente_response_data [0] ['id'];

		$usrLogado = UsuarioLogado::getUsuarioId();
		$data_atz = DateUtils::today();
		$hora_atz = DateUtils::now_time();

		$sql = <<<SQL
			insert into requisicao_procedimento 
				(id_pet, id_convenio_procedimento, status_id, usuario_executor, 
				data_requisicao, hora_requisicao, data_execucao, hora_execucao, 
				atualizado_por, data_atualizacao, hora_atualizacao, id_requisitante) values
				(:pet_id:, :cp_id:, :st_id: , :usr_exec:, 
				:data_req:, :hora_req:, :data_exec:, :hora_exec:,
				:usr_atz:, :data_atz:, :hora_atz:, :usr_req:)
		SQL;

		$binds = [ 
			'pet_id' => $idPet,
			'cp_id' => $idConvenioProcedimento,
			'st_id' => 2,
			'usr_exec' => $usr_exec,
			'data_req' => $dataExec,
			'hora_req' => $horaExec,
			'data_exec' => $dataExec,
			'hora_exec' => $horaExec,
			'usr_atz' => $usrLogado,
			'data_atz' => $data_atz,
			'hora_atz' => $hora_atz,
			'usr_req' => $usrLogado
		];
		$conn = db_connect();
		$numrows = $conn->query( $sql, $binds )->numRows;
		$errors = $conn->error();

		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
			return $dao_response;
		}
		$affectRows = $conn->affectedRows();
		if ($affectRows > 0) {
			$dao_response->setStatus( DAOResponseInterface::SUCESS );
			$dao_response->setData( [ 
				'id_requisicao' => $conn->insertID()
			] );
		} else {
			$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
			$dao_response->setData( [ ] );
		}

		return $dao_response;

	}

	public function adminUpdateConsultaIdNewReqExame(int $requisicao_id, int $consulta_id): DAOResponse {

		$usrLogado = UsuarioLogado::getUsuarioId();
		$data_atz = DateUtils::today();
		$hora_atz = DateUtils::now_time();

		$sql = <<<SQL
			update 
				requisicao_procedimento
			set
				id_consulta = :consulta_id: ,
				atualizado_por = :usr_logado:,
				data_atualizacao = :data_atz:,
				hora_atualizacao = :hora_atz:
			where
				id = :requisicao_id:
		SQL;

		$binds = [ 
			'requisicao_id' => $requisicao_id,
			'consulta_id' => $consulta_id,
			'usr_atz' => $usrLogado,
			'data_atz' => $data_atz,
			'hora_atz' => $hora_atz,
			'usr_logado' => $usrLogado
		];

		$dao_response = new DAOResponse();
		$conn = db_connect();
		$numrows = $conn->query( $sql, $binds )->numRows;
		$errors = $conn->error();

		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
			return $dao_response;
		}

		$affectRows = $conn->affectedRows();

		if ($affectRows > 0) {
			$dao_response->setStatus( DAOResponseInterface::SUCESS );
		} else {
			$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
			$dao_response->setData( [ ] );
		}

		return $dao_response;

	}

	public function getDadosRequisicaoID(int $requisicao_id): DAOResponse {

		$dao_response = new DAOResponse();

		$sql = <<<SQL
			select
				rp.id, rp.id_pet, rp.id_medico, rp.status_id , 
				rp.data_requisicao, rp.hora_requisicao, rp. id_requisitante
			from 
				requisicao_procedimento rp
			where
				rp.id = :id_requisiacao:
		SQL;
		$binds = [ 
			'id_requisiacao' => $requisicao_id
		];

		$conn = db_connect();
		$result = $conn->query( $sql, $binds )
			->getResultArray();
		$errors = $conn->error();

		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
		} else {
			if (count( $result ) > 0) {
				$dao_response->setStatus( DAOResponseInterface::SUCESS );
				$dao_response->setData( $result [0] );
			} else {
				$dao_response->setStatus( DAOResponseInterface::RECORD_NOT_FOUND );
			}
		}

		return $dao_response;

	}

	public function registerRequisicaoFromOrcamento(OrcamentoClienteItemDetalhe $orcamentoDetalhe, array $orcamento): DAOResponse {

		$dao_response = new DAOResponse();

		$sql = <<<SQL
			insert into requisicao_procedimento
				(id_convenio_procedimento, status_id,  
				data_requisicao, hora_requisicao, data_execucao, hora_execucao, 
				id_pet, id_requisitante)
			values
				(:id_convenio_procedimento:, :status_id:, 
		        :data_requisicao:, :hora_requisicao:, :data_execucao:, :hora_execucao:, 
				:id_pet: , :id_requisitante: )
		SQL;

		$binds = [ 
			'id_convenio_procedimento' => $orcamentoDetalhe->getIdConvenioProcedimento(),
			'status_id' => 1,
			'id_pet' => $orcamento ['id_pet'],
			'usuario_executor' => null,
			'data_requisicao' => DateUtils::today(),
			'hora_requisicao' => DateUtils::now_time(),
			'data_execucao' => '1900-01-01',
			'hora_execucao' => '00:00:00',
			'id_requisitante' => UsuarioLogado::getUsuarioId()
		];

		$conn = db_connect();
		$result = $conn->query( $sql, $binds )->numRows;
		$errors = $conn->error();
		
		if ($errors ['code'] != 0) {
			$dao_response->setErrors( $errors );
			$dao_response->setData( [ ] );
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
		} else {
			$newId = $conn->insertID();
			$dao_response->setStatus( DAOResponseInterface::SUCESS );
			$dao_response->setData( ['id_requisicao' => $newId] );
		}
		
		return $dao_response;
		

	}
}

