sothis-contratacao-api/src/modules/contratacao/contratacao.service.js

const geogridService = require("../../shared/apis/geogridService.js");
const googleService = require("../../shared/apis/googleService.js");
const hubsoftService = require("../../shared/apis/hubsoftService.js");
const logger = require('../../shared/utils/logger.js');
const repository = require('./contratacao.repository.js');
const { ViabilidadeModel, ClientModelPf, ClientModelPj, ProspectModel, ViabilidadeReverseGeocodeModel } = require('./contratacao.model');

// utilitário para ler chaves do payload tolerante a ":" e espaços
const getPayloadValue = (obj, key) => {
    if (!obj) return undefined;
    // variações diretas
    const variants = [key, `${key}:`, `${key}: `];
    for (const v of variants) if (Object.prototype.hasOwnProperty.call(obj, v)) return obj[v];
    // tentativa de correspondência normalizada (ignora ":" e case)
    const nk = String(key).trim().toLowerCase();
    for (const k of Object.keys(obj)) {
        const kn = String(k).trim().replace(/:$/, '').toLowerCase();
        if (kn === nk) return obj[k];
    }
    return undefined;
};

// Classe de erro personalizada para o serviço

class ServiceError extends Error {
    constructor(message, statusCode = 500) {
        super(message);
        this.name = 'ServiceError';
        this.statusCode = statusCode;
    }
}

// Função para verificar a viabilidade de um endereço

async function verificarViabilidade(rawViabilidadeData) {
    const rawCep = rawViabilidadeData.cep;
    const rawNumero = rawViabilidadeData.numero;
    const source = rawViabilidadeData.source || '';

    let address;
    let addressString;

    if (!rawCep || !rawNumero) {
        logger.warn('CEP ou número não fornecidos na verificação de viabilidade.');
        throw new ServiceError('CEP e número são obrigatórios.', 400);
    }

    try {
        const cep = require('cep-promise');
        address = await cep(rawCep);
        logger.info('Endereço obtido com sucesso via cep-promise', { address });
    } catch (err) {
        logger.error('Erro ao obter endereço com cep-promise', { message: err.message, stack: err.stack, rawCep });
        throw new ServiceError('Não foi possível obter endereço para o CEP informado ou o CEP é inválido.', 502);
    }


    // Obtém as coordenadas geográficas do endereço usando o Google Geocoding API

    const { street, neighborhood, city, state, cep } = address;
    

    addressString = `${street}, ${rawNumero}, ${neighborhood}, ${city}, ${state}, ${rawCep}`;
    logger.info('Endereço montado para geocodificação', { addressString });

    if (!street || !neighborhood || !city || !state) {
        logger.error('Dados de endereço incompletos para geocodificação', { address });
        throw new ServiceError('Dados de endereço indefinidos:' + addressString, 422);
    }

    const coords = await googleService.geocodeWithGoogle(addressString);
    if (!coords) {
        logger.error('Não foi possível obter coordenadas do Google Geocoding', { addressString });
        throw new ServiceError('Não foi possível obter as coordenadas do endereço.', 500);
    }
    logger.info('Coordenadas obtidas com sucesso', { coords });

    const viabilidade = await geogridService.consultaViabilidade(coords.lat, coords.lon);

    let naoDedicado = false;
    let dedicado = false;

    if (viabilidade.data && viabilidade.data.distancia !== undefined) {
        var distancia = viabilidade.data.distancia;
        logger.info(`Distância para o ponto de presença: ${distancia}m`);
        if (distancia <= 500) {
            naoDedicado = true;
            dedicado = true;
        } else if (distancia <= 1000) {
            naoDedicado = false;
            dedicado = true;
        }
    } else {
        naoDedicado = false;
        dedicado = false;
        var distancia = "5KM+";
        logger.warn('Dados de viabilidade não contêm informação de distância', { viabilidadeData: viabilidade.data });
    }

    

    const viabilidadeResult = new ViabilidadeModel(rawViabilidadeData.nome, rawViabilidadeData.email, rawViabilidadeData.telefone, street, rawNumero, neighborhood, city, state, cep, naoDedicado, dedicado, distancia || null, viabilidade.data.pasta.sigla || null);

    if (source) {
        return viabilidadeResult;
    }

    try {
        await repository.insertViabilidadeData(viabilidadeResult);
        logger.info('Viabilidade salva com sucesso');
    } catch (err) {
        logger.error('Erro ao salvar viabilidade', err);
    }

    return viabilidadeResult;
}

async function verificarGeocodeReverso(lat, lon) {
    const address = await googleService.reverseGeocodeWithGoogle(lat, lon);
    return address;
}

async function verificarViabilidadeLatLong(latitude, longitude) {
    const viabilidade = await geogridService.consultaViabilidade(latitude, longitude);

    let naoDedicado = false;
    let dedicado = false;

    if (viabilidade.data && viabilidade.data.distancia !== undefined) {
        var distancia = viabilidade.data.distancia;
        logger.info(`Distância para o ponto de presença: ${distancia}m`);
        if (distancia <= 500) {
            naoDedicado = true;
            dedicado = true;
        } else if (distancia <= 1000) {
            naoDedicado = false;
            dedicado = true;
        }
    } else {
        naoDedicado = false;
        dedicado = false;
        var distancia = "5KM+";
        logger.warn('Dados de viabilidade não contêm informação de distância', { viabilidadeData: viabilidade.data });
    }

    const address = await verificarGeocodeReverso(latitude, longitude);

    const viabilidadeResult = new ViabilidadeReverseGeocodeModel(address, naoDedicado, dedicado, distancia, viabilidade.data.pasta.sigla || null);

    return viabilidadeResult;
}



async function criarProspecto(rawProspectData) {
    try {
        const payload = (rawProspectData && rawProspectData.prospectData) ? rawProspectData.prospectData : rawProspectData;

        const planos = {
            '100 Mega + Super WiFi': { id_servico: '22' },
            '200 Mega + Super WiFi': { id_servico: '94' },
            '500 Mega + Super WiFi': { id_servico: '96' },
            '700 Mega + Super WiFi': { id_servico: '97' },
            '1 Gb + Super WiFi': { id_servico: '32' },
            '100 Mega + Super WiFi + IP Fixo ': { id_servico: '22' },
            '200 Mega + Super WiFi + IP Fixo': { id_servico: '94' },
            '500 Mega + Super WiFi + IP Fixo': { id_servico: '96' },
            '700 Mega + Super WiFi + IP Fixo': { id_servico: '97' },
            '1 Gb + Super WiFi + IP Fixo': { id_servico: '32' },
        };

        const planoKey = getPayloadValue(payload, 'Descrição');
        const servico = planos[planoKey];
        const celular = Number(String(getPayloadValue(payload, 'Celular')).replace(/\D/g, ''));

        if (!servico) {
            logger.warn('Plano não encontrado no mapeamento', { planoKey, disponíveis: Object.keys(planos) });
            throw new ServiceError('Plano inválido ou não encontrado.', 400);
        }

        // parse do valor mensal de forma robusta (aceita "R$ 119,90", "119,90", etc)
        const rawValor = getPayloadValue(payload, 'Valor (mensal)') || getPayloadValue(payload, 'Valor (mensal):') || getPayloadValue(payload, 'Valor');
        if (rawValor) {
            const sanitized = String(rawValor).replace(/[^\d,.-]/g, '').replace(/\.(?=\d{3})/g, '').replace(',', '.');
            const valorNum = Number(sanitized);
            if (!Number.isNaN(valorNum)) servico.valor = valorNum;
        }
        servico.id_servico = Number(servico.id_servico);
        if (!servico) {
            logger.warn('Plano não encontrado no mapeamento', { planoKey, disponíveis: Object.keys(planos) });
            throw new ServiceError('Plano inválido ou não encontrado.', 400);
        }

        //função que troca a / da data de nascimento por -
        const formatDate = (dateStr) => {
            if (!dateStr) return "";
            return dateStr.replace(/\//g, '-');
        };

        const dataNascimento = formatDate(getPayloadValue(payload, 'Data de nascimento') || "");

        if (payload["CPF:"] === "") {
            // Pessoa Jurídica
            const prospectData = new ProspectModel(
                getPayloadValue(payload, 'CEP'),
                servico, // objeto { id_servico, valor }
                getPayloadValue(payload, 'Razão Social'),   // nomeRazaoSocial
                getPayloadValue(payload, 'CNPJ'),           // cpfCnpj
                celular,                                     // telefone
                getPayloadValue(payload, 'E-mail'),         // email
                "pj",                                        // tipoPessoa
                getPayloadValue(payload, 'Bairro'),         // bairro
                getPayloadValue(payload, 'Logradouro'),     // endereco
                getPayloadValue(payload, 'Número'),         // numero
                "",                                          // nomeMae (não aplicável para PJ)
                getPayloadValue(payload, 'Complemento') || "", // complemento
                ""                                           // dataNascimento (não aplicável)
            );
            console.log(prospectData);
            // serializa para JSON plano conforme toJSON()
            const prospectPayload = (typeof prospectData.pjToJSON === 'function')
                ? prospectData.pjToJSON()
                : JSON.parse(JSON.stringify(prospectData));

            await hubsoftService.criarProspectHubsoft(prospectPayload);
            return prospectPayload;
        } else {
            // Pessoa Física
            const prospectData = new ProspectModel(
                getPayloadValue(payload, 'CEP'),
                servico, // objeto { id_servico, valor }
                getPayloadValue(payload, 'Nome completo'),  // nomeRazaoSocial
                getPayloadValue(payload, 'CPF'),            // cpfCnpj
                celular,                                     // telefone
                getPayloadValue(payload, 'E-mail'),         // email
                "pf",                                        // tipoPessoa
                getPayloadValue(payload, 'Bairro'),         // bairro
                getPayloadValue(payload, 'Logradouro'),     // endereco
                getPayloadValue(payload, 'Número'),         // numero
                getPayloadValue(payload, 'Nome da mãe') || "", // nomeMae
                getPayloadValue(payload, 'Complemento') || "", // complemento
                dataNascimento // dataNascimento
            );
            console.log(prospectData);
            // serializa para JSON plano conforme toJSON()
            const prospectPayload = (typeof prospectData.pfToJSON === 'function')
                ? prospectData.pfToJSON()
                : JSON.parse(JSON.stringify(prospectData));

            // envia objeto plano ao hubsoft (o hubsoftService já monta { prospectData })
            const result = await hubsoftService.criarProspectHubsoft(prospectPayload);

            logger.info('Criando prospecto PF', { prospectPayload });
            return result;
        }
    } catch (error) {
        logger.error('Erro ao criar prospecto', { message: error.message, stack: error.stack });
        throw new ServiceError('Erro ao criar prospecto.', 500);
    }
}


module.exports = {
    verificarViabilidade,
    criarProspecto,
    verificarViabilidadeLatLong,
    verificarGeocodeReverso,
};