const assert = require('node:assert/strict');
const test = require('node:test');

const {
    buildRfmClients,
    buildRfmSegments,
    buildDateFilter,
    getRfmAnalytics,
    getRfmSegment,
    normalizeDateParam,
    scoreTertile
} = require('../services/analyticsService');
const { pool } = require('../db');

test('normalizeDateParam accepts strict ISO dates', () => {
    assert.equal(normalizeDateParam('2026-05-28'), '2026-05-28');
});

test('normalizeDateParam rejects non-ISO or impossible dates', () => {
    assert.equal(normalizeDateParam('28/05/2026'), null);
    assert.equal(normalizeDateParam('2026-02-31'), null);
    assert.equal(normalizeDateParam(''), null);
});

test('buildDateFilter builds bounded date predicates', () => {
    const filter = buildDateFilter({ start: '2026-05-01', end: '2026-05-28' });

    assert.deepEqual(filter.params, ['2026-05-01', '2026-05-28']);
    assert.equal(
        filter.whereClause,
        'WHERE data_pedido_date IS NOT NULL AND data_pedido_date >= $1::date AND data_pedido_date <= $2::date'
    );
});

test('buildDateFilter builds Hoje as an inclusive single-day date predicate', () => {
    const filter = buildDateFilter({ start: '2026-06-15', end: '2026-06-15' });

    assert.deepEqual(filter.params, ['2026-06-15', '2026-06-15']);
    assert.equal(
        filter.whereClause,
        'WHERE data_pedido_date IS NOT NULL AND data_pedido_date >= $1::date AND data_pedido_date <= $2::date'
    );
});

test('buildDateFilter builds Ontem as an inclusive single-day date predicate', () => {
    const filter = buildDateFilter({ start: '2026-06-14', end: '2026-06-14' });

    assert.deepEqual(filter.params, ['2026-06-14', '2026-06-14']);
    assert.equal(
        filter.whereClause,
        'WHERE data_pedido_date IS NOT NULL AND data_pedido_date >= $1::date AND data_pedido_date <= $2::date'
    );
});

test('buildDateFilter builds Ultimos 7 dias as an inclusive calendar range', () => {
    const filter = buildDateFilter({ start: '2026-06-09', end: '2026-06-15' });

    assert.deepEqual(filter.params, ['2026-06-09', '2026-06-15']);
    assert.equal(
        filter.whereClause,
        'WHERE data_pedido_date IS NOT NULL AND data_pedido_date >= $1::date AND data_pedido_date <= $2::date'
    );
});

test('buildDateFilter builds custom single-day ranges inclusively', () => {
    const filter = buildDateFilter({ start: '2026-06-10', end: '2026-06-10' });

    assert.deepEqual(filter.params, ['2026-06-10', '2026-06-10']);
    assert.equal(
        filter.whereClause,
        'WHERE data_pedido_date IS NOT NULL AND data_pedido_date >= $1::date AND data_pedido_date <= $2::date'
    );
});

test('buildDateFilter ignores invalid bounds', () => {
    const filter = buildDateFilter({ start: 'invalid', end: '2026-05-28' });

    assert.deepEqual(filter.params, ['2026-05-28']);
    assert.equal(
        filter.whereClause,
        'WHERE data_pedido_date IS NOT NULL AND data_pedido_date <= $1::date'
    );
});

test('scoreTertile scores higher values higher by default', () => {
    const values = [10, 20, 30, 40, 50];

    assert.equal(scoreTertile(10, values), 1);
    assert.equal(scoreTertile(30, values), 2);
    assert.equal(scoreTertile(50, values), 3);
});

test('scoreTertile can score lower values higher for recency', () => {
    const recencyDays = [2, 10, 20, 40, 80];

    assert.equal(scoreTertile(2, recencyDays, false), 3);
    assert.equal(scoreTertile(20, recencyDays, false), 2);
    assert.equal(scoreTertile(80, recencyDays, false), 1);
});

test('getRfmSegment maps the 3x3 RFM matrix', () => {
    assert.deepEqual(getRfmSegment(3, 3), { key: 'champions', label: 'Champions' });
    assert.deepEqual(getRfmSegment(2, 2), { key: 'need_attention', label: 'Precisam de Atenção' });
    assert.deepEqual(getRfmSegment(1, 1), { key: 'lost', label: 'Perdidos' });
});

test('buildRfmSegments summarizes segment count and revenue', () => {
    const segments = buildRfmSegments([
        { segmentKey: 'champions', monetary: 100 },
        { segmentKey: 'champions', monetary: 50 },
        { segmentKey: 'lost', monetary: 25 }
    ]);

    const champions = segments.find(segment => segment.key === 'champions');
    const lost = segments.find(segment => segment.key === 'lost');

    assert.equal(champions.count, 2);
    assert.equal(champions.totalRevenue, 150);
    assert.equal(champions.averageRevenue, 75);
    assert.equal(lost.count, 1);
    assert.equal(lost.totalRevenue, 25);
});

test('buildRfmClients keeps a yesterday buyer in the same high-recency segment when it is the only qualifying client', () => {
    const sevenDayClients = buildRfmClients([
        { name: 'Cliente Ontem', phone: '1', monetary: 500, frequency: 2, quantityPurchased: 2, lastPurchaseDate: '2026-06-14', recencyDays: 1 }
    ]);
    const yesterdayClients = buildRfmClients([
        { name: 'Cliente Ontem', phone: '1', monetary: 500, frequency: 2, quantityPurchased: 2, lastPurchaseDate: '2026-06-14', recencyDays: 0 }
    ]);

    assert.equal(sevenDayClients[0].segmentKey, 'champions');
    assert.equal(yesterdayClients[0].segmentKey, 'champions');
    assert.equal(sevenDayClients[0].phone, yesterdayClients[0].phone);
});

test('getRfmAnalytics calculates recency against selected range end date', async () => {
    const originalQuery = pool.query;
    const calls = [];

    pool.query = async (sql, params) => {
        calls.push({ sql, params });
        return {
            rows: [
                {
                    name: 'Cliente Ontem',
                    phone: '1',
                    monetary: 500,
                    frequency: 2,
                    quantity_purchased: 2,
                    last_purchase_date: '2026-06-14',
                    recency_days: params[2] === '2026-06-14' ? 0 : 1
                }
            ]
        };
    };

    try {
        const sevenDays = await getRfmAnalytics({ start: '2026-06-09', end: '2026-06-15' });
        const yesterday = await getRfmAnalytics({ start: '2026-06-14', end: '2026-06-14' });

        assert.match(calls[0].sql, /\(\$3::date - MAX\(data_pedido_date\)\)::int/);
        assert.deepEqual(calls[0].params, ['2026-06-09', '2026-06-15', '2026-06-15']);
        assert.deepEqual(calls[1].params, ['2026-06-14', '2026-06-14', '2026-06-14']);
        assert.equal(sevenDays.clients[0].segmentKey, 'champions');
        assert.equal(yesterday.clients[0].segmentKey, 'champions');
        assert.equal(yesterday.clients[0].recencyDays, 0);
    } finally {
        pool.query = originalQuery;
    }
});