<?php
    namespace Zampet\Module\Tutor\v0\Models;

    use Exception;
    use Zampet\Services\DB;
    use Zampet\Module\Tutor\v0\DTO\PetDTO;
    use Zampet\Module\Tutor\v0\DTO\PetRacaDTO;
    use Zampet\Module\Auth\v0\Models\UsuarioModel;

    class PetModel {
        protected string $petTable = 'pet';
        protected string  $usuarioPet = 'usuario_pet';
        protected string  $petAuxRacaTable = 'pet_aux_raca';
        protected string  $petAuxEspecieTable = 'pet_aux_especie';

        /**
         * Lista todos os pets associados a um tutor, buscando o tutor por um identificador flexível.
         *
         * Este método busca primeiro o registro do tutor usando um identificador (UUID, ID, e-mail, etc.) e, em seguida, usa o ID interno do tutor para consultar todos os pets a ele associados.
         *
         * #### Fluxo de Operação:
         * 1.  **Busca do Tutor:** Utiliza `UsuarioModel::getUsuarioByIdentifier` para buscar os dados do tutor. Se o tutor não for encontrado, lança uma `Exception` com o código 404.
         * 2.  **Consulta dos Pets:** Executa uma consulta `SELECT` que une as tabelas de associação (`up`), pets (`p`), raças (`par`) e espécies (`pae`) para obter uma lista detalhada de todos os pets vinculados ao `usuario_id` do tutor.
         * 3.  **Verificação de Pets:**
         * * Se a consulta não retornar pets (`empty($petsUsuario)`), retorna um array com `status` 'fail' e uma mensagem informativa.
         * * Se pets forem encontrados, retorna um array com `status` 'success', código `200 OK` e os dados dos pets na chave `output`.
         *
         * #### Tratamento de Erros:
         * - Qualquer `Exception` lançada durante o processo (como tutor não encontrado ou erro de consulta) é capturada.
         * - Retorna um array com `status` 'error', o código de resposta HTTP da exceção e uma mensagem descritiva.
         *
         * @param string $identifier A coluna da tabela de usuário a ser usada para identificar o tutor (ex: 'uuid', 'id').
         * @param mixed $value O valor correspondente ao identificador do tutor.
         * @return array Um array associativo contendo o status da operação, o código HTTP e os dados dos pets (`output['data']`), ou uma mensagem de erro.
         */
        public function listPetsByTutorIdentifier(string $identifier, mixed $value): array {
            try {
                $usuarioData = (new UsuarioModel())->getUsuarioByIdentifier(identifier: $identifier, value: $value);
                if(!$usuarioData) {
                    throw new Exception(message: 'Tutor not found', code: 404);
                }
                $usuarioData = $usuarioData['output']['data'];

                $sql = 
                "SELECT
                    p.id,
                    p.uuid,
                    p.nome,
                    p.especie_id,
                    pae.descricao AS especie,
                    p.raca_id,
                    par.descricao AS raca,
                    p.caminho_foto,
                    p.registro_geral_animal,
                    p.photo_path,
                    p.data_nascimento,
                    p.data_obito,
                    p.sexo,
                    p.created_at,
                    p.updated_at,
                    p.deleted_at
                FROM {$this->usuarioPet} up
                LEFT JOIN {$this->petTable} p ON up.pet_id = p.id
                LEFT JOIN {$this->petAuxRacaTable} par ON p.raca_id = par.id
                LEFT JOIN {$this->petAuxEspecieTable} pae ON p.especie_id = pae.id
                WHERE up.usuario_id = :usuario_id";

                $params = [
                    ':usuario_id' => $usuarioData['id'],
                ];

                $petsUsuario = DB::fetchAll(sql: $sql, params: $params);
                if(empty($petsUsuario)) {
                    return [
                        'response_code' => 200,
                        'status' => 'success',
                        'message' => 'Você não possui pets cadastrados.',
                        'output' => [
                            'data' => []
                        ]
                    ];
                }

                return [
                    'response_code' => 200,
                    'status' => 'success',
                    'message' => 'Pets encontrados com sucesso.',
                    'output' => [
                        'data' => $petsUsuario
                    ]
                ];
            } catch(Exception $e) {
                return [
                    'response_code' => $e->getCode() ?? 500,
                    'status' => 'error',
                    'message' => $e->getMessage(),
                ];
            }
        }

        /**
         * Lista todas as espécies de pets disponíveis no sistema auxiliar.
         *
         * Este método consulta a tabela de espécies (`{$this->petAuxEspecieTable}`) e retorna uma lista de todos os registros (ID e descrição).
         *
         * #### Fluxo de Operação:
         * 1.  **Execução da Consulta:** Executa uma consulta `SELECT` para buscar todos os IDs e descrições da tabela auxiliar de espécies.
         * 2.  **Verificação de Resultados:**
         * - Se a consulta for bem-sucedida, mas **não retornar nenhuma espécie** (`empty($stmt)`), retorna um array com `status` 'fail' e código `200 OK`.
         * - Se a consulta for bem-sucedida e **retornar espécies**, retorna um array com `status` 'success', código `200 OK` e os dados encontrados na chave `output`.
         *
         * #### Tratamento de Erros:
         * - Qualquer `Exception` capturada durante a consulta retorna um array com `status` 'error', o código de erro da exceção e uma mensagem detalhada de erro.
         *
         * @return array Um array associativo contendo o status da operação, o código de resposta HTTP e os dados das espécies (`output['data']`).
         */
        public function getAllEspecies(): array {
            try {
                $sql =
                "SELECT
                    id,
                    uuid,
                    descricao
                FROM {$this->petAuxEspecieTable}";

                $result = DB::fetchAll(sql: $sql);
                if(empty($result)) {
                    return [
                        'response_code' => 200,
                        'status' => 'success',
                        'message' => 'Nenhuma espécie encontrada.',
                        'output' => [
                            'data' => []
                        ]
                    ];
                }

                $preparedResult = [];
                foreach($result as $key => $especie) {
                    $sql = 
                    "SELECT
                        uuid,
                        descricao
                    FROM {$this->petAuxRacaTable}
                    WHERE especie_id = :especie_id";

                    $params = [
                        ':especie_id' => $especie['id']
                    ];
                    
                    $result = DB::fetchAll(sql: $sql, params: $params);

                    $preparedResult[] = [
                        'uuid' => $especie['uuid'],
                        'descricao' => $especie['descricao'],
                        'racas' => $result
                    ];
                }

                return [
                    'response_code' => 200,
                    'status' => 'success',
                    'message' => 'Espécies encontradas com sucesso.',
                    'output' => [
                        'data' => $preparedResult
                    ]
                ];
            } catch(Exception $e) {
                return [
                    'response_code' => $e->getCode() ?? 500,
                    'status' => 'error',
                    'message' => $e->getMessage(),
                ];
            }
        }

        /**
         * Busca uma única espécie de pet no banco de dados por um identificador específico.
         *
         * Este método recupera os dados de uma espécie da tabela auxiliar `{$this->petAuxEspecieTable}` de forma flexível, permitindo a busca por qualquer coluna (como 'id' ou 'uuid') e o valor correspondente.
         *
         * #### Fluxo de Operação:
         * 1.  **Execução da Consulta:** O método monta e executa uma consulta `SELECT` que usa o `$identifier` de forma dinâmica na cláusula `WHERE` e um parâmetro nomeado seguro (`:value`) para o valor. A consulta utiliza `DB::fetchOne`, indicando que apenas um registro é esperado.
         * 2.  **Verificação de Resultados:**
         * - Se a consulta for bem-sucedida e **nenhuma espécie for encontrada** (`empty($result)`), retorna um array com **`status` 'fail'** e código **200 OK**.
         * - Se uma espécie for encontrada, retorna um array com **`status` 'success'**, código **200 OK** e os dados do registro na chave `output`.
         *
         * #### Tratamento de Erros:
         * - Qualquer `Exception` capturada durante a consulta retorna um array com **`status` 'error'**, o código de erro da exceção e uma mensagem de erro detalhada.
         *
         * @param string $identifier A coluna da tabela a ser usada como critério de busca (ex: 'id', 'uuid', 'descricao').
         * @param mixed $value O valor correspondente ao identificador que está sendo buscado.
         * @return array Um array associativo contendo o status da operação, um código de resposta HTTP e os dados da espécie, se encontrada.
         */
        public function getEspecieByIdentifier(string $identifier, mixed $value): array {
            try {
                $sql =
                "SELECT
                    id, 
                    uuid, 
                    descricao
                FROM {$this->petAuxEspecieTable}
                WHERE {$identifier} = :value
                ORDER BY descricao ASC";

                $params = [
                    ':value' => $value
                ];

                $result = DB::fetchOne(sql: $sql, params: $params);
                if(empty($result)) {
                    return [
                        'response_code' => 200,
                        'status' => 'success',
                        'message' => 'Espécie não encontrada.',
                        'output' => [
                            'data' => []
                        ]
                    ];
                }

                return [
                    'response_code' => 200,
                    'status' => 'success',
                    'message' => 'Espécie encontrada com sucesso.',
                    'output' => [
                        'data' => $result
                    ]
                ];
            } catch(Exception $e) {
                return [
                    'response_code' => $e->getCode() ?? 500,
                    'status' => 'error',
                    'message' => $e->getMessage(),
                ];
            }
        }

         /**
         * Busca uma única raça de pet no banco de dados por um identificador específico.
         *
         * Este método recupera os dados de uma raça da tabela auxiliar `{$this->petAuxRacaTable}` de forma flexível, permitindo a busca por qualquer coluna como identificador (`$identifier`) e o valor correspondente. A consulta retorna apenas um registro e é ordenada pela descrição.
         *
         * #### Fluxo de Operação:
         * 1.  **Execução da Consulta:** O método monta e executa uma consulta `SELECT` que usa o `$identifier` de forma dinâmica na cláusula `WHERE` e um parâmetro nomeado seguro (`:value`) para o valor.
         * 2.  **Verificação de Resultados:**
         * - Se uma raça for encontrada, retorna um array com **`status` 'success'**, código **200 OK** e os dados da raça na chave `output`.
         * - Se a consulta for bem-sucedida, mas **nenhuma raça for encontrada** (`empty($result)`), retorna um array com **`status` 'success'** (indicando que a consulta foi bem-sucedida) e uma mensagem de "Raça não encontrada.".
         *
         * #### Tratamento de Erros:
         * - Qualquer `Exception` capturada durante a consulta retorna um array com **`status` 'error'**, o código de erro da exceção (ou `500` como fallback) e uma mensagem de erro detalhada.
         *
         * @param string $identifier A coluna da tabela a ser usada como critério de busca (ex: 'uuid', 'id', 'descricao').
         * @param mixed $value O valor correspondente ao identificador que está sendo buscado.
         * @return array Um array associativo contendo o status da operação, um código de resposta HTTP e os dados da raça, se encontrada.
         */
        public function getRacaByIdentifier(string $identifier, mixed $value): array {
            try {
                $sql =
                "SELECT
                    id, 
                    uuid, 
                    especie_id, 
                    descricao
                FROM {$this->petAuxRacaTable}
                WHERE {$identifier} = :value
                ORDER BY descricao ASC";

                $params = [
                    ':value' => $value
                ];

                $result = DB::fetchOne(sql: $sql, params: $params);
                if(empty($result)) {
                    return [
                        'response_code' => 200,
                        'status' => 'success',
                        'message' => 'Raça não encontrada.',
                        'output' => [
                            'data' => []
                        ]
                    ];
                }

                return [
                    'response_code' => 200,
                    'status' => 'success',
                    'message' => 'Raça encontrada com sucesso.',
                    'output' => [
                        'data' => $result
                    ]
                ];
            } catch(Exception $e) {
                return [
                    'response_code' => $e->getCode() ?? 500,
                    'status' => 'error',
                    'message' => $e->getMessage(),
                ];
            }
        }

        /**
         * Busca todas as raças de pets associadas a uma espécie específica.
         *
         * Este método primeiro consulta a espécie usando um identificador (UUID, ID, etc.) e, em seguida, usa o ID interno da espécie para listar todas as raças vinculadas a ela na tabela auxiliar `{$this->petAuxRacaTable}`.
         *
         * #### Fluxo de Operação:
         * 1.  **Busca da Espécie:** O método chama `getEspecieByIdentifier` para encontrar o ID da espécie. Se a busca falhar, o resultado de erro é retornado imediatamente.
         * 2.  **Consulta das Raças:** Executa uma consulta `SELECT` que busca todas as raças onde `especie_id` corresponde ao ID da espécie encontrado. Os resultados são ordenados alfabeticamente pela descrição.
         * 3.  **Verificação de Resultados:**
         * - Se a consulta for bem-sucedida, mas **nenhuma raça for encontrada**, retorna um array com **`status` 'fail'** e código **200 OK**.
         * - Se raças forem encontradas, retorna um array com **`status` 'success'**, código **200 OK** e os dados encontrados na chave `output`.
         *
         * #### Tratamento de Erros:
         * - Qualquer `Exception` capturada durante o processo (além daquelas tratadas na busca inicial) retorna um array com **`status` 'error'**, o código de erro da exceção e uma mensagem de erro detalhada.
         *
         * @param string $identifier A coluna da tabela auxiliar de espécies a ser usada para identificar a espécie (ex: 'uuid', 'id').
         * @param mixed $value O valor correspondente ao identificador da espécie.
         * @return array Um array associativo contendo o status da operação, o código de resposta HTTP e os dados das raças (`output['data']`).
         */
        public function getRacasByEspecieIdentifier(string $identifier, mixed $value): array {
            try {
                $especieData = $this->getEspecieByIdentifier(identifier: $identifier, value: $value);
                if($especieData['status'] !== 'success') {
                    return $especieData;
                }
                $especieData = $especieData['output']['data'];

                $sql = 
                "SELECT
                    id,
                    uuid,
                    descricao
                FROM {$this->petAuxRacaTable}
                WHERE especie_id = :especie_id
                ORDER BY descricao ASC";

                $params = [
                    ':especie_id' => $especieData['id']
                ];

                $racas = DB::fetchAll(sql: $sql, params: $params);
                if(empty($racas)) {
                    return [
                        'response_code' => 200,
                        'status' => 'success',
                        'message' => 'Nenhuma raça encontrada para a espécie informada.',
                        'output' => [
                            'data' => []
                        ]
                    ];
                }

                return [
                    'response_code' => 200,
                    'status' => 'success',
                    'message' => 'Raças encontradas com sucesso.',
                    'output' => [
                        'data' => $racas
                    ]
                ];
            } catch(Exception $e) {
                return [
                    'response_code' => $e->getCode() ?? 500,
                    'status' => 'error',
                    'message' => $e->getMessage(),
                ];
            }
        }

        /**
         * Armazena uma nova raça de pet no banco de dados.
         *
         * Este método insere os dados de uma nova raça na tabela auxiliar `{$this->petAuxRacaTable}`. A raça é associada a uma espécie existente. A operação utiliza um bloco `try-catch` para garantir o tratamento de erros.
         *
         * #### Fluxo de Operação:
         * 1.  **Execução da Query:** Prepara e executa a instrução `INSERT` para inserir o novo registro com o UUID, ID da espécie e a descrição.
         * 2.  **Confirmação e Retorno de Sucesso:** Se a inserção for bem-sucedida, retorna um array com **`status` 'success'**, código **201 Created** e uma mensagem de êxito.
         *
         * #### Tratamento de Erros:
         * - Qualquer `Exception` capturada durante o processo retorna um array com **`status` 'error'**, o código de erro da exceção e uma mensagem detalhada de erro.
         *
         * @param PetRacaDTO $petRacaDTO O objeto DTO contendo o UUID, o ID da espécie (`especie_id`) e a descrição da raça a ser criada.
         * @return array Um array associativo contendo o status da operação, o código de resposta HTTP e uma mensagem.
         */
        public function storeRaca(PetRacaDTO $petRacaDTO): array {
            try {
                $sql =
                "INSERT INTO {$this->petAuxRacaTable} (
                    uuid, 
                    especie_id, 
                    descricao
                ) VALUES (
                    :uuid, 
                    :especie_id, 
                    :descricao
                )";

                $params = [
                    ':uuid' => $petRacaDTO->getUuid(),
                    ':especie_id' => $petRacaDTO->getEspecieId(),
                    ':descricao' => $petRacaDTO->getDescricao()
                ];

                DB::execute(sql: $sql, params: $params);

                return [
                    'response_code' => 201,
                    'status' => 'success',
                    'message' => 'Raça armazenada com sucesso.',
                    'output' => [
                        'data' => [
                            'id' => DB::lastInsertId(),
                            'uuid' => $petRacaDTO->getUuid(),
                            'especie_id' => $petRacaDTO->getEspecieId(),
                            'descricao' => $petRacaDTO->getDescricao()
                        ]
                    ]
                ];
            } catch(Exception $e) {
                return [
                    'response_code' => $e->getCode() ?? 500,
                    'status' => 'error',
                    'message' => $e->getMessage(),
                ];
            }
        }

        /**
         * Armazena um novo pet no banco de dados.
         *
         * Este método insere os dados de um novo pet na tabela `{$this->petTable}`, utilizando um objeto `PetDTO` que encapsula todas as informações relevantes. A operação é atômica e utiliza um bloco `try-catch` para garantir o tratamento de erros.
         *
         * #### Fluxo de Operação:
         * 1.  **Execução da Query:** Prepara e executa a instrução `INSERT` para inserir o novo registro com todos os detalhes do pet (UUID, nome, espécie, raça, dados de saúde, foto, etc.).
         * 2.  **Confirmação e Retorno de Sucesso:** Se a inserção for bem-sucedida, retorna um array com **`status` 'success'**, código **201 Created** e uma mensagem de êxito. Os dados do pet recém-criado, incluindo o ID gerado pelo banco, são retornados na chave `output`.
         *
         * #### Tratamento de Erros:
         * - Qualquer `Exception` capturada durante o processo retorna um array com **`status` 'error'**, o código de erro da exceção e uma mensagem detalhada de erro.
         *
         * @param PetDTO $petDTO O objeto DTO contendo os dados do pet a ser criado.
         * @return array Um array associativo contendo o status da operação, o código de resposta HTTP e os dados do pet, se a operação for bem-sucedida.
         */
        public function storePet(PetDTO $petDTO): array {
            try {
                $sql =
                "INSERT INTO {$this->petTable} (
                    uuid, 
                    nome, 
                    especie_id, 
                    raca_id, 
                    caminho_foto, 
                    registro_geral_animal, 
                    photo_path, 
                    data_nascimento, 
                    data_obito, 
                    sexo, 
                    created_at, 
                    updated_at, 
                    deleted_at
                ) VALUES (
                    :uuid, 
                    :nome, 
                    :especie_id, 
                    :raca_id, 
                    :caminho_foto, 
                    :registro_geral_animal, 
                    :photo_path, 
                    :data_nascimento, 
                    :data_obito, 
                    :sexo, 
                    :created_at, 
                    :updated_at, 
                    :deleted_at
                )";

                $params = [
                    ':uuid' => $petDTO->getUuid(),
                    ':nome' => $petDTO->getNome(),
                    ':especie_id' => $petDTO->getEspecieId(),
                    ':raca_id' => $petDTO->getRacaId(),
                    ':caminho_foto' => $petDTO->getCaminhoFoto(),
                    ':registro_geral_animal' => $petDTO->getRegistroGeralAnimal(),
                    ':photo_path' => $petDTO->getPhotoPath(),
                    ':data_nascimento' => $petDTO->getDataNascimento(),
                    ':data_obito' => $petDTO->getDataObito(),
                    ':sexo' => $petDTO->getSexo(),
                    ':created_at' => $petDTO->getCreatedAt(),
                    ':updated_at' => $petDTO->getUpdatedAt(),
                    ':deleted_at' => $petDTO->getDeletedAt()
                ];

                DB::execute(sql: $sql, params: $params);

                return [
                    'response_code' => 201,
                    'status' => 'success',
                    'message' => 'Pet armazenado com sucesso.',
                    'output' => [
                        'data' => [
                            'id' => DB::lastInsertId(),
                            'uuid' => $petDTO->getUuid(),
                            'nome' => $petDTO->getNome(),
                            'especie_id' => $petDTO->getEspecieId(),
                            'raca_id' => $petDTO->getRacaId(),
                            'caminho_foto' => $petDTO->getCaminhoFoto(),
                            'registro_geral_animal' => $petDTO->getRegistroGeralAnimal(),
                            'photo_path' => $petDTO->getPhotoPath(),
                            'data_nascimento' => $petDTO->getDataNascimento(),
                            'data_obito' => $petDTO->getDataObito(),
                            'sexo' => $petDTO->getSexo(),
                            'created_at' => $petDTO->getCreatedAt(),
                            'updated_at' => $petDTO->getUpdatedAt(),
                            'deleted_at' => $petDTO->getDeletedAt()
                        ]
                    ]
                ];
            } catch(Exception $e) {
                return [
                    'response_code' => $e->getCode() ?? 500,
                    'status' => 'error',
                    'message' => $e->getMessage(),
                ];
            }
        }

        /**
         * Associa um pet a um usuário (tutor) no banco de dados.
         *
         * Este método insere um novo registro na tabela de associação `{$this->usuarioPet}`, estabelecendo a relação de propriedade entre o usuário e o pet.
         *
         * #### Fluxo de Operação:
         * 1.  **Execução da Query:** Prepara e executa a instrução `INSERT` para inserir os IDs do usuário e do pet na tabela de associação.
         * 2.  **Retorno de Sucesso:** Se a inserção for bem-sucedida, retorna um array com **`status` 'success'**, código **201 Created** e uma mensagem de êxito.
         *
         * #### Tratamento de Erros:
         * - Qualquer `Exception` capturada durante o processo retorna um array com **`status` 'error'**, o código de erro da exceção (ou `500` como fallback) e uma mensagem detalhada de erro.
         *
         * @param int $usuario_id O ID do usuário (tutor) a ser associado.
         * @param int $pet_id O ID do pet a ser associado.
         * @return array Um array associativo contendo o status da operação, um código de resposta HTTP e uma mensagem.
         */
        public function storeUsuarioPet(int $usuario_id, int $pet_id): array {
            try {
                $sql =
                "INSERT INTO {$this->usuarioPet} (
                    usuario_id, 
                    pet_id
                ) VALUES (
                    :usuario_id, 
                    :pet_id
                )";

                $params = [
                    ':usuario_id' => $usuario_id,
                    ':pet_id' => $pet_id
                ];

                DB::execute(sql: $sql, params: $params);

                return [
                    'response_code' => 201,
                    'status' => 'success',
                    'message' => 'Associação entre usuário e pet criada com sucesso.'
                ];
            } catch(Exception $e) {
                return [
                    'response_code' => $e->getCode() ?? 500,
                    'status' => 'error',
                    'message' => $e->getMessage(),
                ];
            }
        }

        /**
         * Busca um único pet no banco de dados por um identificador específico.
         *
         * Este método recupera todos os detalhes de um pet da tabela `{$this->petTable}`. A busca é flexível e permite usar qualquer coluna como identificador (`$identifier`) e o valor correspondente.
         *
         * #### Fluxo de Operação:
         * 1.  **Execução da Query:** O método monta e executa uma consulta `SELECT` que usa o `$identifier` de forma dinâmica na cláusula `WHERE`. A consulta usa `DB::fetchOne`, indicando que apenas um registro é esperado, e ordena o resultado pelo nome.
         * 2.  **Verificação de Resultados:**
         * - Se o pet for encontrado, retorna um array com **`status` 'success'**, código **200 OK** e os dados do pet na chave `output`.
         * - Se o pet **não for encontrado** (`empty($result)`), retorna um array com **`status` 'success'** (indicando que a consulta foi bem-sucedida) e uma mensagem de "Pet não encontrado.".
         *
         * #### Tratamento de Erros:
         * - Qualquer `Exception` capturada durante o processo retorna um array com **`status` 'error'**, o código de erro da exceção (ou `500` como fallback) e uma mensagem de erro detalhada.
         *
         * @param string $identifier A coluna da tabela a ser usada como critério de busca (ex: 'uuid', 'id', 'registro_geral_animal').
         * @param string $value O valor correspondente ao identificador que está sendo buscado.
         * @return array Um array associativo contendo o status da operação, um código de resposta HTTP e os dados do pet, se encontrado.
         */
        public function getPetByIdentifier(string $identifier, string $value): array {
            try {
                $sql =
                "SELECT
                    p.id, 
                    p.uuid, 
                    p.nome, 
                    p.especie_id, 
                    pae.descricao AS especie,
                    p.raca_id, 
                    par.descricao AS raca,
                    p.caminho_foto, 
                    p.registro_geral_animal, 
                    p.photo_path, 
                    p.data_nascimento, 
                    p.data_obito, 
                    p.sexo, 
                    p.created_at, 
                    p.updated_at, 
                    p.deleted_at
                FROM {$this->petTable} p
                LEFT JOIN {$this->petAuxRacaTable} par ON p.raca_id = par.id
                LEFT JOIN {$this->petAuxEspecieTable} pae ON p.especie_id = pae.id
                WHERE p.{$identifier} = :value
                ORDER BY p.nome ASC";

                $params = [
                    ':value' => $value
                ];

                $result = DB::fetchOne(sql: $sql, params: $params);
                if(empty($result)) {
                    return [
                        'response_code' => 200,
                        'status' => 'success',
                        'message' => 'Pet não encontrado.',
                        'output' => [
                            'data' => []
                        ]
                    ];
                }

                return [
                    'response_code' => 200,
                    'status' => 'success',
                    'message' => 'Pet encontrado com sucesso.',
                    'output' => [
                        'data' => $result
                    ]
                ];
            } catch(Exception $e) {
                return [
                    'response_code' => $e->getCode() ?? 500,
                    'status' => 'error',
                    'message' => $e->getMessage(),
                ];
            }
        }
    }