<?php

namespace App\DAO;

use App\DAO\DAOResponse\DAOResponse;
use App\DAO\DAOResponse\DAOResponseInterface;
use App\DAO\Filter\QueryFilterTranslator;
use App\DAO\Pagination\Pagination;
use App\Entities\Assistente\Assistente;
use App\Entities\AssistenteMedico\AssistenteMedico;
use App\Entities\CEP\CEP;
use App\Entities\Cliente\Cliente;
use App\Entities\ConfirmacaoEmail\ConfirmacaoEmail;
use App\Entities\Endereco\Endereco;
use App\Entities\Paciente\Paciente;
use App\Entities\Pessoa\Pessoa;
use App\Entities\PessoaFisica\PessoaFisica;
use App\Entities\Profissional\Profissional;
use App\Entities\ProfissionalClinica\ProfissionalClinica;
use App\Entities\Recepcao\Recepcionista;
use App\Entities\Usuario\Usuario;
use App\Entities\UsuarioPerfil\UsuarioPerfil;
use App\Mappers\AssistenteMapper;
use App\Mappers\RecepcaoMapper;
use App\Models\AssistenteMedicoModel;
use App\Models\AssistenteModel;
use App\Models\CEPModel;
use App\Models\ClienteModel;
use App\Models\ConfirmacaoEmailModel;
use App\Models\EnderecoModel;
use App\Models\PacienteModel;
use App\Models\PessoaFisicaModel;
use App\Models\PessoaModel;
use App\Models\ProfissionalClinicaModel;
use App\Models\ProfissionalModel;
use App\Models\RecepcionistaModel;
use App\Models\UsuarioModel;
use App\Models\UsuarioPerfilModel;
use App\Services\LogService;
use App\Services\ServiceResponse\ServiceResponseInterface;
use App\Services\UnidadeService;
use App\Utils\Collections\QueryFilterCollection;
use App\Utils\Collections\QueryOrderCollection;
use App\ViewModels\Assistente\AssistenteRegistrationViewModel\AssistenteRegistrationViewModel;
use App\ViewModels\Recepcao\RecepcaoRegistrationViewModel\RecepcaoRegistrationViewModel;
use App\ViewModels\Recepcao\RecepcionistaRegistrationViewModel\RecepcionistaRegistrationViewModel;
use App\ViewModels\Recepcao\RecepcionistaUpdateViewModel\RecepcionistaUpdateViewModel;
use Exception;

class RecepcaoDAO extends DAO {

	public function persistRecepcionistaRegistrationVM(RecepcionistaRegistrationViewModel $recepcao_registration_vm): DAOResponse {

		$dao_response = new DAOResponse();
		try {
			$this->db->transStart();
			$cep = $this->persistCepFromRecepcionistaRegistrationVM( $recepcao_registration_vm );
			$endereco = $this->persistEnderecoFromRecepcionistaRegistrationVM( $recepcao_registration_vm, $cep );
			$pessoa = $this->persistPessoaFromRecepcionistaRegistrationVM( $recepcao_registration_vm, $endereco );
			$usuario = $this->persistUsuarioFromRecepcionistaRegistrationVM( $recepcao_registration_vm, $pessoa );
			$pessoa_fisica = $this->persistPessoaFisicaFromRecepcionistaRegistrationVM( $recepcao_registration_vm, $pessoa );
			$usuario_perfil = $this->persistUsuarioPerfilFromRecepcionistaRegistrationVM( $recepcao_registration_vm, $usuario );
			$profissional = $this->persistProfissionalFromRecepcionistaRegistrationVM( $recepcao_registration_vm, $pessoa );
			$profissional_clinica = $this->persistProfissionalClinicaFromRecepcionistaRegistrationVM( $recepcao_registration_vm, $profissional );
			$recepcionista = $this->persistAssistenteFromRecepcionistaRegistrationVM( $recepcao_registration_vm, $profissional );
			$paciente = $this->persistPacienteFromRecepcaoRegistrationVM( $recepcao_registration_vm, $pessoa );
			# $cliente = $this->persistClienteFromRecepcaoRegistrationVM( $recepcao_registration_vm, $pessoa );
			// $asssitente_medico = $this->persistAssistenteMedicoFromRecepcaoRegistrationVM( $recepcao_registration_vm, $assistente );
			// if ($recepcao_registration_vm->getTokenConfirmacaoEmail()) {
			// $confirmacao_email = $this->persistConfirmacaoEmailFromAssistenteRegistrationVM( $recepcao_registration_vm, $usuario );
			// }

			$error = $this->db->error();
			if ($error && $error ['code']) {
				$this->setDatabaseErrorsForAssistenteRegistration( $dao_response, $error );
			} else {
				// $status_service_response_send_email = $send_email();
				$status_service_response_send_email = ServiceResponseInterface::SUCESS;
				if ($status_service_response_send_email === ServiceResponseInterface::SUCESS) {
					$dao_response->setStatus( DAOResponseInterface::SUCESS );
					$dao_response->setData( $recepcionista );
					$this->db->transComplete();
				} else {
					(new LogService())->log_error( $status_service_response_send_email,
						'Falha no envio do email de confirmação de cadastro de um recepcionista.', $recepcao_registration_vm->toArray() );
					$dao_response->setStatus( DAOResponseInterface::INTERNAL_DAO_ERROR );
				}
			}
		} catch ( Exception $exception ) {
			$this->setDatabaseErrorsForAssistenteRegistration( $dao_response, $this->db->error() );
		}

		// Bloco para setar senha do chame facil após o cadastro

		// $_dados = [
		// 'senha_chamefacil' => $recepcao_registration_vm->getSenhaChameFacil()
		// ];
		// $user = new UsuarioModel();
		// $user->updateUsuarioID($usuario->getId(), $_dados);

		// Fim do bloco para setar senha do chame facil após o cadastro

		return $dao_response;

	}

	private function setDatabaseErrorsForRecepcaoRegistration(DAOResponse $dao_response, array $error): void {

		if ($error ['code']) {
			$dao_response->setStatus( $error ['code'] );
			$dao_response->setErrors( $this->getDatabaseResponseErrorsForPersistence( $error ) );
		} else {
			$dao_response->setStatus( DAOResponseInterface::DATABASE_CONNECTION_ERROR );
		}
		log_message( 'error', json_encode( $error ) );

	}

	private function persistCepFromRecepcionistaRegistrationVM(RecepcionistaRegistrationViewModel &$recepcao_registration_vm): CEP {

		$cep_model = new CEPModel();
		$cep = RecepcaoMapper::getCepFromRecepcaoRegistrationVM( $recepcao_registration_vm );
		$cep_model->registerCep( $cep );
		if (!$cep->getId()) {
			throw new Exception( 'O cadastro de cep não foi teve êxito' );
		}
		return $cep;

	}

	private function persistEnderecoFromRecepcionistaRegistrationVM(RecepcionistaRegistrationViewModel &$recepcao_registration_vm, CEP $cep): Endereco {

		$endereco_model = new EnderecoModel();
		$endereco = RecepcaoMapper::getEnderecoFromRecepcaoRegistrationVM( $recepcao_registration_vm, $cep );
		$endereco_model->registerEndereco( $endereco );
		if (!$endereco->getId()) {
			throw new Exception( 'O cadastro de endereço não foi teve êxito' );
		}
		return $endereco;

	}

	private function persistPessoaFromRecepcionistaRegistrationVM(RecepcionistaRegistrationViewModel &$recepcao_registration_vm, Endereco &$endereco): Pessoa {

		$pessoa_model = new PessoaModel();
		$pessoa = RecepcaoMapper::getPessoaFromRecepcaoRegistrationVM( $recepcao_registration_vm, $endereco );
		$pessoa_model->registerPessoa( $pessoa );
		if (!$pessoa->getId()) {
			throw new Exception( 'O cadastro de pessoa não foi teve êxito' );
		}
		return $pessoa;

	}

	private function persistPessoaFisicaFromRecepcionistaRegistrationVM(RecepcionistaRegistrationViewModel &$recepcao_registration_vm, Pessoa &$pessoa): PessoaFisica {

		$pessoa_fisica_model = new PessoaFisicaModel();

		$pessoa_fisica = new PessoaFisica();
		$pessoa_fisica->setIdPessoa( $pessoa->getId() );
		$pessoa_fisica->setCpf( $recepcao_registration_vm->getCpf() );
		$pessoa_fisica->setRg( $recepcao_registration_vm->getRg() );
		$pessoa_fisica->setGenero( $recepcao_registration_vm->getGenero() );
		$pessoa_fisica->setDataNascimento( $recepcao_registration_vm->getDataNascimento() );
		$pessoa_fisica->setNome( $recepcao_registration_vm->getNome() );
		$pessoa_fisica->setProfissao( $recepcao_registration_vm->getProfissao() );
		$pessoa_fisica->setEstadoCivil( $recepcao_registration_vm->getEstadoCivil() );

		// $pessoa_fisica = RecepcaoMapper::getPessoaFisicaFromRecepcaoRegistrationVM($recepcao_registration_vm, $pessoa );
		$pessoa_fisica_model->registerPessoaFisica( $pessoa_fisica );
		if (!$pessoa_fisica->getId()) {
			throw new Exception( 'O cadastro de pessoa fisica não foi teve êxito' );
		}
		return $pessoa_fisica;

	}

	private function persistUsuarioFromRecepcionistaRegistrationVM(RecepcionistaRegistrationViewModel &$recepcao_registration_vm, Pessoa &$pessoa): Usuario {

		$usuario_model = new UsuarioModel();
		$usuario = RecepcaoMapper::getUsuarioFromRecepcaoRegistrationVM( $recepcao_registration_vm, $pessoa );
		$usuario_model->registerUsuario( $usuario );
		if (!$usuario->getId()) {
			throw new Exception( 'O cadastro de usuário não foi teve êxito' );
		}
		return $usuario;

	}

	private function persistPacienteFromRecepcaoRegistrationVM(RecepcionistaRegistrationViewModel &$recepcao_registration_vm, Pessoa &$pessoa): Paciente {

		$paciente_model = new PacienteModel();
		$paciente = RecepcaoMapper::getPacienteFromRecepcaoRegistrationVM( $recepcao_registration_vm, $pessoa );
		$paciente_model->registerPaciente( $paciente );
		if (!$paciente->getId()) {
			throw new Exception( 'O cadastro de paciente não foi teve êxito' );
		}
		return $paciente;

	}

	private function persistClienteFromRecepcaoRegistrationVM(RecepcionistaRegistrationViewModel &$recepcao_registration_vm, Pessoa &$pessoa): Cliente {

		$cliente_model = new ClienteModel();
		$cliente = RecepcaoMapper::getClienteFromRecepcaoRegistrationVM( $recepcao_registration_vm, $pessoa );
		$cliente_model->registerCliente( $cliente );
		if (!$cliente->getId()) {
			throw new Exception( 'O cadastro de cliente não foi teve êxito' );
		}
		return $cliente;

	}

	private function persistUsuarioPerfilFromRecepcionistaRegistrationVM(RecepcionistaRegistrationViewModel &$recepcao_registration_vm, Usuario &$usuario): UsuarioPerfil {

		$usuario_perfil_model = new UsuarioPerfilModel();
		$usuario_perfil = RecepcaoMapper::getUsuarioPerfilFromRecepcaoRegistrationVM( $recepcao_registration_vm, $usuario );
		$usuario_perfil_model->registerUsuarioPerfil( $usuario_perfil );
		if (!$usuario_perfil->getId()) {
			throw new Exception( 'O cadastro de usuario_perfil não foi teve êxito' );
		}
		return $usuario_perfil;

	}

	private function persistConfirmacaoEmailFromRecepcaoRegistrationVM(RecepcionistaRegistrationViewModel &$recepcao_registration_vm, Usuario &$usuario): ConfirmacaoEmail {

		$confirmacao_email_model = new ConfirmacaoEmailModel();
		$confirmacao_email = RecepcaoMapper::getConfirmacaoEmailFromRecepcaoRegistrationVM( $recepcao_registration_vm, $usuario );
		$confirmacao_email_model->registerConfirmacaoEmail( $confirmacao_email );
		if (!$confirmacao_email->getId()) {
			throw new Exception( 'O cadastro de confirmacao_email não foi teve êxito' );
		}
		return $confirmacao_email;

	}

	private function persistProfissionalFromRecepcionistaRegistrationVM(RecepcionistaRegistrationViewModel &$recepcao_registration_vm, Pessoa &$pessoa): Profissional {

		$profissional_model = new ProfissionalModel();
		$profissional = RecepcaoMapper::getProfissionalFromRecepcaoRegistrationVM( $recepcao_registration_vm, $pessoa );
		$profissional_model->registerProfissional( $profissional );
		if (!$profissional->getId()) {
			throw new Exception( 'O cadastro de profissional não foi teve êxito' );
		}
		return $profissional;

	}

	private function persistProfissionalClinicaFromRecepcionistaRegistrationVM(RecepcionistaRegistrationViewModel &$recepcao_registration_vm,
			Profissional &$pessoa): ProfissionalClinica {

		$profissional_clinica_model = new ProfissionalClinicaModel();

		if (count( $recepcao_registration_vm->getUnidades() ) > 1) {
			foreach ( $recepcao_registration_vm->getUnidades() as $value ) {
				$profissional_clinica = RecepcaoMapper::getProfissionalClinicaFromProfissionalClinicaRegistrationVM( $value, $pessoa );
				$profissional_clinica_model->registerProfissionalClinica( $profissional_clinica );
			}
		} else {
			$profissional_clinica = RecepcaoMapper::getProfissionalClinicaFromProfissionalClinicaRegistrationVM( $recepcao_registration_vm->getUnidades() [0],
				$pessoa );
			$profissional_clinica_model->registerProfissionalClinica( $profissional_clinica );
		}

		if (!$profissional_clinica->getId()) {
			throw new Exception( 'O cadastro de assistente_clinica não foi teve êxito' );
		}
		return $profissional_clinica;

	}

	private function persistAssistenteFromRecepcionistaRegistrationVM(RecepcionistaRegistrationViewModel &$recepcao_registration_vm, Profissional &$pessoa): Recepcionista {

		$recepcionista_model = new RecepcionistaModel();
		$recepcionista = RecepcaoMapper::getAssistenteFromRecepcaoRegistrationVM( $recepcao_registration_vm, $pessoa );
		$recepcionista_model->registerRecepcionista( $recepcionista );
		if (!$recepcionista->getId()) {
			throw new Exception( 'O cadastro de assistente não teve êxito' );
		}
		return $recepcionista;

	}

	private function persistAssistenteMedicoFromAssistenteRegistrationVM(AssistenteRegistrationViewModel &$assistente_registration_vm, Assistente &$pessoa): AssistenteMedico {

		$assistente_medico_model = new AssistenteMedicoModel();
		foreach ( $assistente_registration_vm->getIdMedico() as $value ) :
			$assistente_medico = AssistenteMapper::getAssistenteMedicoFromAssistenteRegistrationVM( $value, $pessoa->getId() );
			$assistente_medico_model->registerAssistenteMedico( $assistente_medico );
			if (!$assistente_medico->getId()) {
				throw new Exception( 'O cadastro de assistente_medico não foi teve êxito' );
			}
		endforeach
		;
		return $assistente_medico;

	}

	public function getRecepcionistaList(?Pagination $pagination, ?QueryFilterCollection $query_filter_collection,
			?QueryOrderCollection $query_order_collection = null): DAOResponse {

		$sql = <<<SQL
			SELECT
				assistente.id as id, pessoa_fisica.cpf as cpf, pessoa_fisica.rg as rg,
				pessoa_fisica.nome as nome,	pessoa_fisica.genero as genero,
				pessoa_fisica.profissao as profissao, pessoa_fisica.estado_civil as estado_civil,
				SUBSTRING(pessoa_fisica.data_nascimento, 1, 10) AS data_nascimento,
				pessoa.telefone_1 as telefone_1, pessoa.telefone_2 as telefone_2,
				cep.cep as cep, cep.estado as estado, cep.cidade as cidade,
				cep.bairro as bairro, cep.logradouro as logradouro,
				endereco.numero as numero, endereco.complemento as complemento,
				endereco.referencias as referencias, usuario.email as email,
				usuario.ativo as ativo, usuario_status.descricao as ativo_desc,
				usuario.foto as foto, perfil.id as perfil_id, perfil.descricao as perfil_descricao
			FROM
				perfil, pessoa , pessoa_fisica, usuario ,usuario_status, usuario_perfil,
				profissional , assistente , endereco, cep
			WHERE
				perfil.id = 56
				AND pessoa.id = pessoa_fisica.id_pessoa
				AND usuario.id_pessoa = pessoa.id
				AND usuario.ativo = usuario_status.id
				AND profissional.id_pessoa = pessoa.id
				AND usuario_perfil.id_usuario = usuario.id
				AND profissional.id = assistente.id_profissional
				AND pessoa.id_endereco = endereco.id
				AND perfil.id = usuario_perfil.id_perfil
				AND cep.id = endereco.cep
		SQL;
		$binds = [ ];
		return $this->getDAOResponseFromPaginatedSelect( $binds, $pagination, $query_filter_collection, $query_order_collection, $sql,
			function (array $result_array) {
				return RecepcaoMapper::getRecepcionistaDetailsVMListFromArray( $result_array );
			} );

	}

	public function getRecepcionista(QueryFilterCollection $query_filter_collection): DAOResponse {

		$sql = '
            SELECT
                assistente.id as id,
                pessoa_fisica.cpf as cpf,
                pessoa_fisica.rg as rg,
                pessoa_fisica.nome as nome,
                pessoa_fisica.genero as genero,
                pessoa_fisica.profissao as profissao,
                pessoa_fisica.estado_civil as estado_civil,
                SUBSTRING(pessoa_fisica.data_nascimento, 1, 10) AS data_nascimento,
                pessoa.telefone_1 as telefone_1,
                pessoa.telefone_2 as telefone_2,
                cep.cep as cep,
                endereco.numero as numero,
                endereco.complemento as complemento,
                endereco.referencias as referencias,
                cep.estado as estado,
                cep.cidade as cidade,
                cep.bairro as bairro,
                cep.logradouro as logradouro,
                usuario.email as email,
                usuario.id as id_usuario,
				usuario.ativo as ativo, 
				usuario_status.descricao as ativo_desc,
                usuario.foto as foto,
                perfil.id as perfil_id,
                perfil.descricao as perfil_descricao                
            FROM assistente, pessoa, profissional, pessoa_fisica, usuario, usuario_status,endereco, cep, usuario_perfil, perfil
            WHERE 
                assistente.id_profissional = profissional.id 
				AND profissional.id_pessoa = pessoa.id 
				AND pessoa.id = pessoa_fisica.id_pessoa 
				AND pessoa.id = usuario.id_pessoa 
				AND pessoa.id_endereco = endereco.id 
				AND endereco.cep = cep.id 
				AND usuario.ativo = usuario_status.id
				AND usuario_perfil.id_usuario = usuario.id 
				AND perfil.id = usuario_perfil.id_perfil
            	
        ';
		$binds = [ ];
		return $this->getDAOResponseFromUniqueRowSelect( $binds, $query_filter_collection, $sql,
			function (array $result_array) {
				return RecepcaoMapper::getRecepcionistaDetailsVMFromArray( $result_array [0] );
			} );

	}

	public function getMedicosFromAssistenteList(int $id_assistente) {

		$sql = '
            SELECT 
            medico.id as id_medico,   
            pessoa_fisica.nome
            FROM 
                assistente_medico, medico, profissional, pessoa_fisica 
                WHERE 
            	assistente_medico.id_medico = medico.id AND
            	medico.id_profissional = profissional.id AND
				profissional.id_pessoa = pessoa_fisica.id_pessoa AND
            	assistente_medico.id_assistente = :id_assistente:
        ';
		$binds = [ 
			'id_assistente' => $id_assistente
		];
		$query = $this->db->query( $sql, $binds );
		$result_array = $query->getResultArray();
		return $result_array;

	}

	private function getDatabaseResponseErrorsForPersistence(array $error): array {

		$dao_response_errors = [ ];
		if ($error && $error ['code']) {
			if ($error ['code'] === DAOResponseInterface::FOREIGN_KEY_DONT_EXISTS) {
				if (strpos( $error ['message'], 'cep' ) !== false) {
					$dao_response_errors ['cep'] = 'Esse cep não existe.';
				}
			} else if ($error ['code'] === DAOResponseInterface::DUPLICATED_UNIQUE_KEY) {
				if (strpos( $error ['message'], '\'cpf\'' ) !== false) {
					$dao_response_errors ['cpf'] = 'Uma pessoa com esse CPF já está cadastrada no sistema.';
				}
				if (strpos( $error ['message'], '\'rg\'' ) !== false) {
					$dao_response_errors ['rg'] = 'Uma pessoa com esse RG já está cadastrada no sistema.';
				}
				if (strpos( $error ['message'], '\'email\'' ) !== false) {
					$dao_response_errors ['email'] = 'Uma pessoa com esse email já está cadastrada no sistema.';
				}
			}
		}
		return $dao_response_errors;

	}

	public function verifyAssistenteAndMedicoAreLinked(int $id_medico, int $assistente_uid): DAOResponse {

		$sql = '
            SELECT
                1
            FROM assistente_medico, assistente, profissional, usuario
            WHERE 
                assistente_medico.id_assistente = assistente.id AND
                profissional.id = assistente.id_profissional AND
                usuario.id_pessoa = profissional.id_pessoa AND
                usuario.id = :assistente_uid: AND
                id_medico = :id_medico:
            LIMIT 1
        ';
		$binds = [ 
			'id_medico' => $id_medico,
			'assistente_uid' => $assistente_uid
		];
		return $this->getDAOResponseFromUniqueRowSelect( $binds, null, $sql, function (array $result_array): bool {
			return true;
		} );

	}

	public function persistRecepcionistaUpdateVM(int $id_recepcionista, RecepcionistaUpdateViewModel $recepcionista_update_vm): DAOResponse {

		$dao_response = new DAOResponse();
		$this->db->transStart();
		$status_persistence = $this->persistCepFromRecepcionistaUpdateVM( $id_recepcionista, $recepcionista_update_vm );
		$status_persistence = $this->persistEnderecoFromRecepcionistaUpdateVM( $id_recepcionista, $recepcionista_update_vm );
		$status_persistence = $status_persistence && $this->persistPessoaFromRecepcionistaUpdateVM( $id_recepcionista, $recepcionista_update_vm );
		$status_persistence = $status_persistence && $this->persistUsuarioFromRecepcionistaUpdateVM( $id_recepcionista, $recepcionista_update_vm );
		$status_persistence = $status_persistence && $this->persistUsuarioPerfilFromRecepcionistaUpdateVM( $id_recepcionista, $recepcionista_update_vm );
		// $status_persistence = $status_persistence && $this->persistPacienteFromRecepcionistaUpdateVM( $id_recepcionista, $recepcionista_update_vm );
		$status_persistence = $status_persistence && $this->persistPessoaFisicaFromRecepcionistaUpdateVM( $id_recepcionista, $recepcionista_update_vm );
		// $status_persistence = $status_persistence && $this->persistAssistenteMedicoFromRecepcionistaUpdateVM( $id_recepcionista, $recepcionista_update_vm );
		$error = $this->db->error();
		if ($error && $error ['code']) {
			$this->setDatabaseErrorsForAssistenteUpdate( $dao_response, $error );
			return $dao_response;
		} else if ($status_persistence) {
			$this->db->transComplete();
			$dao_response->setStatus( DAOResponseInterface::SUCESS );
		}
		$this->db->close();
		return $dao_response;

	}

	private function setDatabaseErrorsForAssistenteUpdate(DAOResponse $dao_response, array $error): void {

		$dao_response->setStatus( $error ['code'] );
		$dao_response->setErrors( $this->getDatabaseResponseErrorsForPersistence( $error ) );

	}

	private function persistCepFromRecepcionistaUpdateVM(int $id_recepcionista, RecepcionistaUpdateViewModel &$recepcionista_update_vm): bool {

		$cep_model = new CEPModel();
		$cep = RecepcaoMapper::getCepFromRecepcionistaUpdateVM( $recepcionista_update_vm );
		$sucess_update = $cep_model->updateCepByRecepcionistaID( $id_recepcionista, $cep );
		return $sucess_update;

	}

	private function persistEnderecoFromRecepcionistaUpdateVM(int $id_paciente, RecepcionistaUpdateViewModel &$assistente_update_vm): bool {

		$endereco_model = new EnderecoModel();
		$endereco = RecepcaoMapper::getEnderecoFromAssistenteUpdateVM( $assistente_update_vm );
		$sucess_update = $endereco_model->updateEnderecoByAssistenteID( $id_paciente, $endereco );
		return $sucess_update;

	}

	private function persistPessoaFromRecepcionistaUpdateVM(int $id_assistente, RecepcionistaUpdateViewModel &$assistente_update_vm): bool {

		$pessoa_model = new PessoaModel();
		$pessoa = RecepcaoMapper::getPessoaFromAssistenteUpdateVM( $assistente_update_vm );
		$sucess_update = $pessoa_model->updatePessoaByAssistenteID( $id_assistente, $pessoa );
		return $sucess_update;

	}

	private function persistPessoaFisicaFromRecepcionistaUpdateVM(int $id_assistente, RecepcionistaUpdateViewModel &$assistente_update_vm): bool {

		$pessoa_fisica_model = new PessoaFisicaModel();
		$pessoa_fisica = RecepcaoMapper::getPessoaFisicaFromAssistenteUpdateVM( $assistente_update_vm );
		$sucess_update = $pessoa_fisica_model->updatePessoaFisicaByAssistenteID( $id_assistente, $pessoa_fisica );
		return $sucess_update;

	}

	private function persistUsuarioFromRecepcionistaUpdateVM(int $id_assistente, RecepcionistaUpdateViewModel &$assistente_update_vm): bool {

		$usuario_model = new UsuarioModel();
		$usuario = RecepcaoMapper::getUsuarioFromAssistenteUpdateVM( $assistente_update_vm );
		$sucess_update = $usuario_model->updateUsuarioByAssistenteID( $id_assistente, $usuario );
		return $sucess_update;

	}

	private function persistUsuarioPerfilFromRecepcionistaUpdateVM(int $id_assistente, RecepcionistaUpdateViewModel &$assistente_update_vm): bool {

		$usuario_model = new UsuarioPerfilModel();
		$usuario = RecepcaoMapper::getUsuarioPerfilFromAssistenteUpdateVM( $assistente_update_vm );
		$sucess_update = $usuario_model->updatePerfilByAssistenteID( $id_assistente, $usuario );
		return $sucess_update;

	}

	private function persistPacienteFromRecepcionistaUpdateVM(int $id_assistente, RecepcionistaUpdateViewModel &$assistente_update_vm): bool {

		$paciente_model = new PacienteModel();
		$paciente = RecepcaoMapper::getPacienteFromAssistenteUpdateVM( $assistente_update_vm );
		$sucess_update = $paciente_model->updatePacienteByAssistenteID( $id_assistente, $paciente );
		return $sucess_update;

	}

	private function persistAssistenteMedicoFromRecepcionistaUpdateVM(int $id_assistente, RecepcionistaUpdateViewModel &$assistente_update_vm): bool {

		$assistente_medico_model = new AssistenteMedicoModel();
		$this->deleteMedicosFromAssistenteList( $id_assistente );
		$sucess = true;
		foreach ( $assistente_update_vm->getIdMedico() as $value ) :
			$assistente_medico = RecepcaoMapper::getAssistenteMedicoFromAssistenteRegistrationVM( $value, $id_assistente );
			$assistente_medico_model->registerAssistenteMedico( $assistente_medico );
			if (!$assistente_medico->getId()) {
				$sucess = false;
			}
		endforeach
		;
		return $sucess;

	}

	public function deleteMedicosFromAssistenteList(int $id_assistente) {

		$sql = '
            DELETE FROM assistente_medico WHERE id_assistente = :id_assistente:
        ';
		$binds = [ 
			'id_assistente' => $id_assistente
		];
		$query = $this->db->query( $sql, $binds );
		$result_array = $query->getResultArray();
		return $result_array;

	}

	public function getImageAssistente(int $id_assistente) {

		$sql = '
            SELECT
                usuario.foto as foto
            FROM assistente, pessoa, profissional, pessoa_fisica, usuario, endereco, cep
            WHERE 
                assistente.id_profissional = profissional.id AND
                profissional.id_pessoa = pessoa.id AND
                pessoa.id = pessoa_fisica.id_pessoa AND
                pessoa.id = usuario.id_pessoa AND
                pessoa.id_endereco = endereco.id AND
                endereco.cep = cep.id AND
            	usuario.ativo = 1 AND assistente.id = :id_assistente:
        ';
		$binds = [ 
			'id_assistente' => $id_assistente
		];
		$query = $this->db->query( $sql, $binds );
		$result_array = $query->getResultArray();
		return (($result_array [0] ['foto']));

	}

	public function getRecepcionistaFromId(int $id_recepcionista) {

		$sql = '
            SELECT 1
            FROM assistente
            WHERE assistente.id = :id_recepcionista:
        ';
		$binds = [ 
			'id_recepcionista' => $id_recepcionista
		];
		$query = $this->db->query( $sql, $binds );
		$result_array = $query->getResultArray();
		return ($result_array);

	}

}