/**
 * Генератор амбиента «Пепельных лугов» — WAV из кода, без зависимостей.
 * Запуск: node tools/audio/gen.mjs
 * Выход:  apps/game/assets/audio/ambience/*.wav
 *
 * Все sfx переехали на спек-синтез (data/sfxSpecs.ts, компилирует движок) —
 * здесь остались только многослойные амбиент-лупы. Формулы бывших sfx
 * экспортированы ниже: их сверяет с рендером спеков парити-тест
 * data/__tests__/sfxSpecs.test.ts (звучание мигрированных звуков не менялось).
 *
 * Формат: моно, 22050 Гц, 16-бит PCM. Меланхоличный пепельный саунд.
 * WAV-энкодер и примитивы синтеза — жанронезависимые, в @rpg/engine/tools/wav.mjs.
 */
import { mkdirSync, writeFileSync } from 'node:fs';
import { fileURLToPath, pathToFileURL } from 'node:url';
import { encodeWav, makeRng, synth, decay, bellPartial, bandNoise, normalize, loopify } from '@rpg/engine/tools/wav.mjs';

const OUT = fileURLToPath(new URL('../../assets/audio/', import.meta.url));

// ---------- звуки ----------

/** Гулкий удар колокольчиком: 4 негармоничных партиала + шумовой клик.
 *  Экспортируется для парити-теста: renderSpec(SPEC_SFX['sfx/bell_hit']) бит-в-бит. */
export function bellHit() {
    const dur = 0.35;
    const s = synth(dur, (t) => {
        const body =
            bellPartial(520, 1.0, dur, 5)(t) * 0.5 +
            bellPartial(520, 1.52, dur, 6)(t) * 0.3 +
            bellPartial(520, 2.38, dur * 0.6, 7)(t) * 0.2 +
            bellPartial(520, 3.91, dur * 0.4, 8)(t) * 0.12;
        const click = t < 0.008 ? (makeRng(1)() * 2 - 1) * (1 - t / 0.008) * 0.4 : 0;
        return body * 0.8 + click;
    });
    return normalize(s, 0.7);
}

/** Низкий резонанс: медленный гул с тремоло — «усыпляет пепел». */
export function bellLow() {
    const dur = 0.9;
    const s = synth(dur, (t) => {
        const trem = 1 + 0.3 * Math.sin(2 * Math.PI * 6 * t);
        const body =
            Math.sin(2 * Math.PI * 110 * t) * 0.5 +
            Math.sin(2 * Math.PI * 165 * t) * 0.25 +
            Math.sin(2 * Math.PI * 220.5 * t) * 0.12;
        return body * decay(t, dur, 2) * trem;
    });
    return normalize(s, 0.6);
}

/** Шипение: сгусток просыпается. */
export function ashHiss() {
    const dur = 0.4;
    const noise = bandNoise(11, 900, 4200, dur);
    const s = synth(dur, (t) => noise() * Math.min(1, t / 0.08) * decay(t, dur, 2));
    return normalize(s, 0.55);
}

/** Смерть сгустка: шум с падающим «выдохом». */
export function ashDie() {
    const dur = 0.6;
    const noise = bandNoise(23, 300, 2400, dur);
    const s = synth(dur, (t) => {
        const pitch = 1 - 0.7 * (t / dur); // темнеет к концу
        return noise() * decay(t, dur, 3) * (0.4 + pitch);
    });
    return normalize(s, 0.6);
}

/** Плевок: синус с падающей высотой + шипящий хвост. */
export function spit() {
    const dur = 0.2;
    const noise = bandNoise(37, 2000, 6000, dur);
    const s = synth(dur, (t) => {
        const f = 700 - 350 * (t / dur);
        return (Math.sin(2 * Math.PI * f * t) * 0.6 + noise() * 0.4) * decay(t, dur, 3);
    });
    return normalize(s, 0.5);
}

/** Урон герою: глухой низкий удар. */
export function hurt() {
    const dur = 0.25;
    const noise = bandNoise(41, 80, 400, dur);
    const s = synth(dur, (t) => {
        const thump = Math.sin(2 * Math.PI * 90 * t) * decay(t, dur, 3);
        return thump * 0.8 + noise() * 0.3 * decay(t, dur * 0.5, 2);
    });
    return normalize(s, 0.65);
}

/** Мот подобран: мерцающий двойной звон (тёплая искра в серой земле). */
export function motePickup() {
    const dur = 0.45;
    const s = synth(dur, (t) => {
        const body =
            Math.sin(2 * Math.PI * 1240 * t) * 0.4 +
            Math.sin(2 * Math.PI * 1860 * t) * 0.2 * decay(t, dur, 4);
        return body * decay(t, dur, 2.5);
    });
    return normalize(s, 0.4);
}

/** Предмет в сумку: мягкий «пок». */
export function pickup() {
    const dur = 0.14;
    const s = synth(dur, (t) => {
        const f = 520 + 220 * (t / dur); // чуть взлетает
        return Math.sin(2 * Math.PI * f * t) * decay(t, dur, 2.5);
    });
    return normalize(s, 0.4);
}

/** Сундук открылся: низкий удар крышки + скрип петель. */
export function chestOpen() {
    const dur = 0.55;
    const noise = bandNoise(157, 300, 1400, dur);
    const s = synth(dur, (t) => {
        const thump = Math.sin(2 * Math.PI * 110 * t) * decay(t, 0.12, 2) * 0.7;
        const creak = noise() * Math.min(1, t / 0.1) * decay(t, dur, 1.5) * 0.35;
        return thump + creak;
    });
    return normalize(s, 0.45);
}

/** Записка: шелест бумаги. */
export function note() {
    const dur = 0.35;
    const noise = bandNoise(159, 1800, 6000, dur);
    const s = synth(dur, (t) => noise() * (0.4 + 0.6 * Math.sin(2 * Math.PI * 3.2 * t + 1)) * decay(t, dur, 1.5));
    return normalize(s, 0.3);
}

/** Переход локаций: воздух уносит — шум с подъёмом и спадом.
 *  Экспортируется для парити-теста (спек sfx/whoosh). */
export function whoosh() {
    const dur = 0.7;
    const noise = bandNoise(160, 200, 2400, dur);
    const s = synth(dur, (t) => {
        const swell = Math.sin(Math.PI * Math.min(1, t / dur)); // 0 → 1 → 0
        return noise() * swell;
    });
    return normalize(s, 0.4);
}

/** Олень вспугнут: глухой выдох + стук копыт. */
export function deerStartle() {
    const dur = 0.4;
    const noise = bandNoise(161, 150, 900, dur);
    const s = synth(dur, (t) => {
        const breath = noise() * Math.min(1, t / 0.05) * decay(t, dur, 2);
        const hoof = t > 0.2 && t < 0.28 ? Math.sin(2 * Math.PI * 90 * (t - 0.2)) * decay(t - 0.2, 0.08, 2) * 0.6 : 0;
        return breath * 0.7 + hoof;
    });
    return normalize(s, 0.4);
}

/** Клик UI. */
export function uiClick() {
    const dur = 0.06;
    const s = synth(dur, (t) => Math.sin(2 * Math.PI * 880 * t) * decay(t, dur, 3) * 0.5);
    return normalize(s, 0.4);
}

/** Колокольчик Милы: высокий, почти хрустальный. */
export function chime() {
    const dur = 0.5;
    const s = synth(dur, (t) => {
        const body =
            Math.sin(2 * Math.PI * 1560 * t) * 0.5 +
            Math.sin(2 * Math.PI * 1560 * 1.61 * t) * 0.25;
        return body * decay(t, dur, 3);
    });
    return normalize(s, 0.45);
}

/** Амбиент лугов: настоящий ветер — воздушная полоса, порывы шумом, зациклен. */
/**
 * Фактура ветра лугов: мягкий низкий шум (120–600 Гц) с «дыханием» — суммой
 * медленных волн — и порывами. Возвращает замыкание t → вклад ветра.
 */
function meadowsWind(seed, dur, { gustCount, gustAmp, breathAmp }) {
    const air = bandNoise(seed, 120, 600, dur);
    const r = makeRng(seed * 31 + 5);
    const gusts = [];
    for (let i = 0; i < gustCount; i++) {
        gusts.push({ at: r() * dur, len: 0.8 + r() * 1.6, amp: (0.5 + r() * 0.5) * gustAmp });
    }
    return (t) => {
        const breath =
            0.5 +
            0.28 * Math.sin((2 * Math.PI * t) / dur + 1) +
            0.14 * Math.sin((4 * Math.PI * t) / dur + 3.1) +
            0.08 * Math.sin((9 * Math.PI * t) / dur + 5.2);
        let v = air() * breathAmp * breath;
        for (const g of gusts) {
            const d = t - g.at + (t < g.at ? dur : 0); // зациклить порывы
            if (d >= 0 && d < g.len) v += air() * g.amp * decay(d, g.len, 1.4);
        }
        return v;
    };
}

/** Шуршание сухой травы: короткие всплески узкой полосы 1.5–3 кГц. */
function grassRustle(seed, dur, count, amp) {
    const rustle = bandNoise(seed, 1500, 3000, dur);
    const r = makeRng(seed * 17 + 3);
    const bursts = [];
    for (let i = 0; i < count; i++) bursts.push({ at: r() * dur, len: 0.1 + r() * 0.25, amp: 0.5 + r() * 0.5 });
    return (t) => {
        let v = 0;
        for (const b of bursts) {
            const d = t - b.at + (t < b.at ? dur : 0);
            if (d >= 0 && d < b.len) v += rustle() * amp * b.amp * decay(d, b.len, 2.5);
        }
        return v;
    };
}

/** Скрип дерева/столба: низкий тон с изгибом частоты, короткий. */
function woodCreak(at, len, f0, amp) {
    return (t) => {
        const d = t - at;
        if (d < 0 || d >= len) return 0;
        // Изгиб частоты: два медленных колебания поверх базовой — «скрип-скрип».
        const f = f0 + 0.35 * f0 * Math.sin((2 * Math.PI * d) / 0.22);
        return Math.sin(2 * Math.PI * f * d) * amp * decay(d, len, 2.2);
    };
}

/**
 * Амбиент лугов: тихий «дыхательный» ветер (мягкий низкий шум с порывами),
 * шуршание сухой травы и редкие события — скрипы деревьев, далёкий звон
 * Звенца. События распределены неравномерно, луп не «пульсирует».
 */
function ambienceMeadows() {
    const dur = 8;
    const wind = meadowsWind(62, dur, { gustCount: 5, gustAmp: 0.22, breathAmp: 0.3 });
    const rustle = grassRustle(63, dur, 7, 0.12);
    const creaks = [
        woodCreak(0.8, 0.5, 140, 0.1),
        woodCreak(3.4, 0.7, 95, 0.12),
        woodCreak(6.1, 0.4, 180, 0.08)
    ];
    const s = synth(dur, (t) => {
        let v = wind(t) + rustle(t);
        for (const creak of creaks) v += creak(t);
        // Далёкий звон Звенца (111 Гц), один за цикл, глухо — сквозь ветер.
        const db = t - 5.3;
        if (db >= 0 && db < 2)
            v += (Math.sin(2 * Math.PI * 111 * db) * 0.05 + Math.sin(2 * Math.PI * 111 * 2.76 * db) * 0.015) * decay(db, 2, 3);
        return v;
    });
    return loopify(normalize(s, 0.32));
}

/** Амбиент прудов: ниже, влажнее, с редкой капелью. */
function ambiencePonds() {
    const dur = 8;
    const wind = bandNoise(71, 60, 400, dur);
    const r = makeRng(13);
    const drops = [];
    for (let i = 0; i < 4; i++) drops.push({ at: r() * dur, f: 900 + r() * 600 });
    const s = synth(dur, (t) => {
        let v = wind() * 0.3 * (0.7 + 0.3 * Math.sin(2 * Math.PI * t / dur + 3));
        for (const d of drops) {
            const dt = t - d.at + (t < d.at ? dur : 0);
            if (dt >= 0 && dt < 0.15) v += Math.sin(2 * Math.PI * d.f * dt * (1 - dt * 3)) * 0.08 * decay(dt, 0.15, 2);
        }
        return v;
    });
    return loopify(normalize(s, 0.5));
}

/**
 * Амбиент Звенца: низкий колокольный тон (два удара за цикл) над тихим
 * ветром. Колокол башни отлит из рельсов — голос ниже лугового гула.
 */
function ambienceZvenets() {
    const dur = 8;
    const wind = bandNoise(81, 80, 500, dur);
    const strikes = [
        { at: 1.0, f: 148 },
        { at: 5.0, f: 111 }
    ];
    const s = synth(dur, (t) => {
        let v = wind() * 0.2 * (0.7 + 0.3 * Math.sin(2 * Math.PI * t / dur + 0.5));
        for (const s of strikes) {
            const dt = t - s.at + (t < s.at ? dur : 0); // зациклить удары
            if (dt >= 0 && dt < 2.5) {
                v +=
                    (Math.sin(2 * Math.PI * s.f * dt) * 0.22 +
                        Math.sin(2 * Math.PI * s.f * 2.76 * dt) * 0.08 +
                        Math.sin(2 * Math.PI * s.f * 5.4 * dt) * 0.04) *
                    decay(dt, 2.5, 3);
            }
        }
        return v;
    });
    return loopify(normalize(s, 0.55));
}

/**
 * Ночь на лугах: воздух ниже и плотнее, свиста нет; вдалеке гудит машина
 * (Ржавая роща не спит) и изредка доходит колокол Звенца.
 */
function ambienceMeadowsNight() {
    const dur = 8;
    // Та же фактура ветра, что днём, но глубже, тише и с меньшими порывами.
    const wind = meadowsWind(72, dur, { gustCount: 3, gustAmp: 0.12, breathAmp: 0.32 });
    const rustle = grassRustle(73, dur, 3, 0.06);
    const hum = bandNoise(74, 40, 160, dur);
    const creaks = [woodCreak(2.2, 0.6, 110, 0.07), woodCreak(6.8, 0.5, 90, 0.05)];
    const s = synth(dur, (t) => {
        let v = wind(t) + rustle(t);
        for (const creak of creaks) v += creak(t);
        // Дальний гул машины: 55 Гц с медленным тремоло, как будто земля дышит.
        v += (Math.sin(2 * Math.PI * 55 * t) * 0.08 + hum() * 0.1) * (0.7 + 0.3 * Math.sin(2 * Math.PI * t / 3));
        // Далёкий колокол: глухой удар, приходящий сквозь ветер.
        const dt = t - 4.6;
        if (dt >= 0 && dt < 2)
            v += (Math.sin(2 * Math.PI * 111 * dt) * 0.08 + Math.sin(2 * Math.PI * 111 * 2.76 * dt) * 0.025) * decay(dt, 2, 3);
        return v;
    });
    return loopify(normalize(s, 0.3));
}

/** Ночь у прудов: ветер почти стих, вода слышна громче, капли чаще. */
function ambiencePondsNight() {
    const dur = 8;
    const wind = bandNoise(83, 50, 250, dur);
    const lap = bandNoise(84, 200, 900, dur);
    const r = makeRng(19);
    const drops = [];
    for (let i = 0; i < 7; i++) drops.push({ at: r() * dur, f: 700 + r() * 500 });
    const s = synth(dur, (t) => {
        let v = wind() * 0.22 * (0.6 + 0.4 * Math.sin(2 * Math.PI * t / dur + 1));
        // Ночью вода «дышит» ровнее и ближе.
        v += lap() * 0.14 * (0.6 + 0.4 * Math.sin(2 * Math.PI * t / dur + 3));
        for (const d of drops) {
            const dt = t - d.at + (t < d.at ? dur : 0);
            if (dt >= 0 && dt < 0.15) v += Math.sin(2 * Math.PI * d.f * dt * (1 - dt * 3)) * 0.09 * decay(dt, 0.15, 2);
        }
        return v;
    });
    return loopify(normalize(s, 0.5));
}

/**
 * Ночь в Звенце: ветер ниже, колокол бьёт реже и глуше, под ним — низкий
 * гул башни, не смолкающий и ночью.
 */
function ambienceZvenetsNight() {
    const dur = 8;
    const wind = bandNoise(93, 60, 350, dur);
    const strikes = [
        { at: 2.0, f: 111 },
        { at: 6.0, f: 98 }
    ];
    const s = synth(dur, (t) => {
        let v = wind() * 0.24 * (0.65 + 0.35 * Math.sin(2 * Math.PI * t / dur + 2.5));
        // Башня не спит: тихий двойной гул под всем прочим.
        v += (Math.sin(2 * Math.PI * 55 * t) * 0.08 + Math.sin(2 * Math.PI * 82.5 * t) * 0.05) * (0.6 + 0.4 * Math.sin(2 * Math.PI * t / dur * 2));
        for (const s of strikes) {
            const dt = t - s.at + (t < s.at ? dur : 0);
            if (dt >= 0 && dt < 2.5)
                v +=
                    (Math.sin(2 * Math.PI * s.f * dt) * 0.2 +
                        Math.sin(2 * Math.PI * s.f * 2.76 * dt) * 0.07 +
                        Math.sin(2 * Math.PI * s.f * 5.4 * dt) * 0.03) *
                    decay(dt, 2.5, 3);
        }
        return v;
    });
    return loopify(normalize(s, 0.55));
}

// ---------- локальные амбиент-слои ----------

/** Слой «зона наката»: низкий шелест пепла + глухой гул — пепел течёт. */
function layerAshflow() {
    const dur = 8;
    const rustle = bandNoise(181, 100, 500, dur);
    const r = makeRng(53);
    const waves = [];
    for (let i = 0; i < 3; i++) waves.push({ at: r() * dur, len: 1.5 + r() });
    const s = synth(dur, (t) => {
        // Гул: два расстроенных низа с медленным биением.
        let v = (Math.sin(2 * Math.PI * 45 * t) * 0.12 + Math.sin(2 * Math.PI * 47.5 * t) * 0.1) * (0.7 + 0.3 * Math.sin(2 * Math.PI * t / dur));
        // Шелест волнами, как будто пепел перекатывается.
        for (const w of waves) {
            const dt = t - w.at + (t < w.at ? dur : 0);
            if (dt >= 0 && dt < w.len) v += rustle() * 0.2 * decay(dt, w.len, 1.2);
        }
        return v;
    });
    return loopify(normalize(s, 0.5));
}

/** Слой «вода прудов»: тихий плеск + редкие капли. */
function layerPondsWater() {
    const dur = 8;
    const lap = bandNoise(172, 300, 1500, dur);
    const r = makeRng(27);
    const drops = [];
    for (let i = 0; i < 6; i++) drops.push({ at: r() * dur, f: 800 + r() * 700 });
    const s = synth(dur, (t) => {
        // Плебск «дышит» медленной волной.
        let v = lap() * 0.12 * (0.5 + 0.5 * Math.sin(2 * Math.PI * t / dur + 2));
        for (const d of drops) {
            const dt = t - d.at + (t < d.at ? dur : 0); // зациклить капли
            if (dt >= 0 && dt < 0.12) v += Math.sin(2 * Math.PI * d.f * dt) * 0.1 * decay(dt, 0.12, 2);
        }
        return v;
    });
    return loopify(normalize(s, 0.5));
}

/** Слой «башня Звенца»: низкий гул колокола (55+82.5 Гц) с биением. */
function layerTowerHum() {
    const dur = 8;
    const s = synth(dur, (t) => {
        const breath = 0.6 + 0.4 * Math.sin(2 * Math.PI * t / dur * 2 + 0.5);
        const body =
            Math.sin(2 * Math.PI * 55 * t) * 0.5 +
            Math.sin(2 * Math.PI * 82.5 * t) * 0.3; // биение 27.5 Гц
        return body * breath * 0.35;
    });
    return loopify(normalize(s, 0.5));
}

/** Слой «дома Звенца»: редкие скрипы вагонных щитов. */
function layerHouses() {
    const dur = 8;
    const noise = bandNoise(174, 200, 1000, dur);
    const r = makeRng(41);
    const creaks = [];
    for (let i = 0; i < 4; i++) creaks.push({ at: r() * dur, len: 0.5 + r() * 0.6 });
    const s = synth(dur, (t) => {
        let v = 0;
        for (const c of creaks) {
            const dt = t - c.at + (t < c.at ? dur : 0); // зациклить скрипы
            if (dt >= 0 && dt < c.len) {
                const wob = 1 + 0.5 * Math.sin(2 * Math.PI * 5 * dt);
                v += noise() * wob * decay(dt, c.len, 1.5) * 0.25;
            }
        }
        return v;
    });
    return loopify(normalize(s, 0.5));
}

/** Слой «ветер» (глобальный): свистящая высокая полоса с редкими порывами. */
function layerWind() {
    const dur = 8;
    const air = bandNoise(175, 300, 1400, dur);
    const r = makeRng(47);
    const gusts = [];
    for (let i = 0; i < 2; i++) gusts.push({ at: r() * dur, len: 2 + r() });
    const s = synth(dur, (t) => {
        let v = air() * 0.18 * (0.55 + 0.45 * Math.sin(2 * Math.PI * t / dur + 1.5));
        for (const g of gusts) {
            const dt = t - g.at + (t < g.at ? dur : 0); // зациклить порывы
            if (dt >= 0 && dt < g.len) v += air() * 0.22 * decay(dt, g.len, 1.5);
        }
        return v;
    });
    return loopify(normalize(s, 0.5));
}

// ---------- запись ----------

const AMBIENCE = {
    'ambience/meadows': ambienceMeadows,
    'ambience/ponds': ambiencePonds,
    'ambience/zvenets': ambienceZvenets,
    // Ночные варианты: ниже, плотнее, с дальними механизмами (кроссфейд по часам).
    'ambience/meadows_night': ambienceMeadowsNight,
    'ambience/ponds_night': ambiencePondsNight,
    'ambience/zvenets_night': ambienceZvenetsNight,
    'ambience/ponds_water': layerPondsWater,
    'ambience/tower_hum': layerTowerHum,
    'ambience/houses': layerHouses,
    'ambience/wind': layerWind,
    'ambience/ashflow': layerAshflow
};
// Записываем WAV только при запуске как CLI, а не при импорте (парити-тест
// импортирует формулы bellHit/whoosh, чтобы сверить их со спек-синтезом).
if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
    mkdirSync(`${OUT}ambience`, { recursive: true });
    for (const [name, gen] of Object.entries(AMBIENCE)) {
        const buf = encodeWav(gen());
        writeFileSync(`${OUT}${name}.wav`, buf);
        console.log(`${name}.wav  ${(buf.length / 1024).toFixed(1)} КБ`);
    }
}