/**
 * ESM test suite for moon-cycle v2.
 * Uses Node.js built-in test runner.
 */

import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import {
  cycleMonth,
  cycleYear,
  imageFolder,
  cdnUrl,
  SYNODIC_MONTH,
  MONTH_IMAGES,
  YEAR_IMAGES,
  MONTH_ANCHOR,
  YEAR_ANCHOR,
} from './dist/index.mjs';

// ─── Constants ───────────────────────────────────────────────────────────────

describe('constants', () => {
  it('SYNODIC_MONTH is correct IAU value', () => {
    assert.strictEqual(SYNODIC_MONTH, 29.53058821398858);
  });

  it('MONTH_IMAGES is 708', () => {
    assert.strictEqual(MONTH_IMAGES, 708);
  });

  it('YEAR_IMAGES is 8760', () => {
    assert.strictEqual(YEAR_IMAGES, 8760);
  });

  it('MONTH_ANCHOR is 2023-11-13T09:27:00Z', () => {
    assert.strictEqual(MONTH_ANCHOR.toISOString(), '2023-11-13T09:27:00.000Z');
  });

  it('YEAR_ANCHOR is 2023-01-01T00:00:00Z', () => {
    assert.strictEqual(YEAR_ANCHOR.toISOString(), '2023-01-01T00:00:00.000Z');
  });
});

// ─── cycleMonth ──────────────────────────────────────────────────────────────

describe('cycleMonth', () => {
  it('returns a string', () => {
    assert.strictEqual(typeof cycleMonth(), 'string');
  });

  it('result matches /^\\d{3}\\.webp$/', () => {
    assert.match(cycleMonth(), /^\d{3}\.webp$/);
  });

  it('result is never 000.webp (images are 1-indexed)', () => {
    const anchor = MONTH_ANCHOR.getTime();
    const synodic_ms = SYNODIC_MONTH * 24 * 60 * 60 * 1000;
    for (let i = 0; i < 100; i++) {
      const date = new Date(anchor + i * (synodic_ms / 100));
      assert.notStrictEqual(cycleMonth(date), '000.webp', `Got 000.webp for offset ${i}`);
    }
  });

  it('at anchor date returns 001.webp (start of synodic cycle)', () => {
    assert.strictEqual(cycleMonth(MONTH_ANCHOR), '001.webp');
  });

  it('one synodic month + 1 min after anchor returns near start of next cycle', () => {
    const oneMonthPlus = new Date(
      MONTH_ANCHOR.getTime() + SYNODIC_MONTH * 24 * 60 * 60 * 1000 + 60_000,
    );
    const index = parseInt(cycleMonth(oneMonthPlus).replace('.webp', ''), 10);
    assert(index <= 3, `Expected near start of next cycle (index <= 3), got ${index}`);
  });

  it('at halfway through synodic month returns ~354.webp', () => {
    const half = new Date(MONTH_ANCHOR.getTime() + (SYNODIC_MONTH / 2) * 24 * 60 * 60 * 1000);
    const index = parseInt(cycleMonth(half).replace('.webp', ''), 10);
    assert(index >= 353 && index <= 355, `Expected ~354, got ${index}`);
  });

  it('result is always in range [001, 708]', () => {
    const start = new Date('2020-01-01T00:00:00Z');
    const step = 24 * 60 * 60 * 1000 * 7;
    for (let i = 0; i < 260; i++) {
      const date = new Date(start.getTime() + i * step);
      const index = parseInt(cycleMonth(date).replace('.webp', ''), 10);
      assert(index >= 1, `Index ${index} below minimum (date: ${date.toISOString()})`);
      assert(index <= 708, `Index ${index} above maximum (date: ${date.toISOString()})`);
    }
  });

  it('handles dates before the anchor (pre-2023)', () => {
    const past = new Date('2020-06-15T00:00:00Z');
    const result = cycleMonth(past);
    assert.match(result, /^\d{3}\.webp$/);
    const index = parseInt(result.replace('.webp', ''), 10);
    assert(index >= 1 && index <= 708);
  });

  it('with no args returns a valid result', () => {
    assert.match(cycleMonth(), /^\d{3}\.webp$/);
  });

  it('throws TypeError for invalid Date', () => {
    assert.throws(() => cycleMonth(new Date('invalid')), {
      name: 'TypeError',
      message: 'date must be a valid Date instance',
    });
  });

  it('throws TypeError for non-Date input', () => {
    assert.throws(() => cycleMonth('2023-01-01'), {
      name: 'TypeError',
      message: 'date must be a valid Date instance',
    });
  });
});

// ─── cycleYear ───────────────────────────────────────────────────────────────

describe('cycleYear', () => {
  it('returns a string', () => {
    assert.strictEqual(typeof cycleYear(), 'string');
  });

  it('result matches /^\\d{4}\\.webp$/', () => {
    assert.match(cycleYear(), /^\d{4}\.webp$/);
  });

  it('result is never 0000.webp (images are 1-indexed)', () => {
    const anchor = YEAR_ANCHOR.getTime();
    const year_ms = YEAR_IMAGES * 60 * 60 * 1000;
    for (let i = 0; i < 100; i++) {
      const date = new Date(anchor + i * (year_ms / 100));
      assert.notStrictEqual(cycleYear(date), '0000.webp', `Got 0000.webp for offset ${i}`);
    }
  });

  it('at anchor date returns 0001.webp (start of year)', () => {
    assert.strictEqual(cycleYear(YEAR_ANCHOR), '0001.webp');
  });

  it('at exactly one year after anchor returns 0001.webp', () => {
    const oneYear = new Date(YEAR_ANCHOR.getTime() + YEAR_IMAGES * 60 * 60 * 1000);
    assert.strictEqual(cycleYear(oneYear), '0001.webp');
  });

  it('at halfway through year returns ~4380.webp', () => {
    const half = new Date(YEAR_ANCHOR.getTime() + (YEAR_IMAGES / 2) * 60 * 60 * 1000);
    const index = parseInt(cycleYear(half).replace('.webp', ''), 10);
    assert(index >= 4379 && index <= 4381, `Expected ~4380, got ${index}`);
  });

  it('result is always in range [0001, 8760]', () => {
    const start = new Date('2020-01-01T00:00:00Z');
    const step = 24 * 60 * 60 * 1000 * 7;
    for (let i = 0; i < 260; i++) {
      const date = new Date(start.getTime() + i * step);
      const index = parseInt(cycleYear(date).replace('.webp', ''), 10);
      assert(index >= 1, `Index ${index} below minimum`);
      assert(index <= 8760, `Index ${index} above maximum`);
    }
  });

  it('handles dates before 2023', () => {
    const past = new Date('2021-06-15T00:00:00Z');
    const result = cycleYear(past);
    assert.match(result, /^\d{4}\.webp$/);
    const index = parseInt(result.replace('.webp', ''), 10);
    assert(index >= 1 && index <= 8760);
  });

  it('with no args returns a valid result', () => {
    assert.match(cycleYear(), /^\d{4}\.webp$/);
  });

  it('throws TypeError for invalid Date', () => {
    assert.throws(() => cycleYear(new Date('invalid')), {
      name: 'TypeError',
      message: 'date must be a valid Date instance',
    });
  });

  it('throws TypeError for non-Date input', () => {
    assert.throws(() => cycleYear('2023-01-01'), {
      name: 'TypeError',
      message: 'date must be a valid Date instance',
    });
  });
});

// ─── imageFolder ─────────────────────────────────────────────────────────────

describe('imageFolder', () => {
  it('returns correct folder name', () => {
    assert.strictEqual(imageFolder('mm', 256, 75), 'mm-256-75');
    assert.strictEqual(imageFolder('mm', 512, 85), 'mm-512-85');
    assert.strictEqual(imageFolder('my', 256, 75), 'my-256-75');
    assert.strictEqual(imageFolder('my', 512, 85), 'my-512-85');
  });
});

// ─── cdnUrl ──────────────────────────────────────────────────────────────────

describe('cdnUrl', () => {
  it('returns a valid jsDelivr URL', () => {
    assert.strictEqual(
      cdnUrl('354.webp', 'mm', 256, 75),
      'https://cdn.jsdelivr.net/gh/acamarata/moon-cycle@main/mm-256-75/354.webp',
    );
  });

  it('respects custom ref parameter', () => {
    assert.strictEqual(
      cdnUrl('001.webp', 'my', 512, 85, 'v2.0.0'),
      'https://cdn.jsdelivr.net/gh/acamarata/moon-cycle@v2.0.0/my-512-85/001.webp',
    );
  });

  it('integrates with cycleMonth output', () => {
    const filename = cycleMonth(MONTH_ANCHOR);
    const url = cdnUrl(filename, 'mm', 256, 75);
    assert(url.startsWith('https://cdn.jsdelivr.net/gh/acamarata/moon-cycle@main/mm-256-75/'));
    assert(url.endsWith('.webp'));
  });
});