/**
 * Погода как часть движка: дождь, снег, ветер, облачность. Слои дождя/снега —
 * те же спрайты-билборды (particles.ts): живут в мировых координатах, окно
 * видимости камеры заворачивает их (маржа за экраном — без «появления из
 * воздуха»), ambient-тинт и точечные источники применяются слоем автоматически.
 * Ветер — глобальный горизонтальный дрейф (вектор из направления и силы),
 * облачность — гашение солнца/ambient рендера (VoxelRenderer.setCloud).
 * Позы детерминированы временем цикла — кадр-равенства гейтов работают.
 */
import type { ParticleLayer } from './particles';
import type { VoxelRenderer } from './voxelRenderer';

/** Спецификация погоды: всё в диапазонах 0..1, ветер — 0..1 + направление. */
export interface WeatherSpec {
    /** Направление ветра, рад (0 — дрейф к +Z, π/2 — к +X). */
    windDir: number;
    /** Сила ветра 0..1 (полная сила — 6 юнит/с дрейфа). */
    windStrength: number;
    /** Облачность 0..1 (гасит солнце и ambient, серее фон). */
    cloud: number;
    /** Интенсивность дождя 0..1. */
    rain: number;
    /** Интенсивность снега 0..1. */
    snow: number;
}

/** Дождь без ветра, ясно — нейтральная погода по умолчанию. */
export const DEFAULT_WEATHER: WeatherSpec = {
    windDir: 0.7, windStrength: 0, cloud: 0, rain: 0, snow: 0,
};

/** Кламп спецификации: частичный ввод (мост/панель) → полная валидная. */
export function clampWeather(w: Partial<WeatherSpec>): WeatherSpec {
    const num = (v: unknown, fallback: number): number =>
        typeof v === 'number' && Number.isFinite(v) ? v : fallback;
    return {
        windDir: num(w.windDir, DEFAULT_WEATHER.windDir),
        windStrength: clamp01(num(w.windStrength, DEFAULT_WEATHER.windStrength)),
        cloud: clamp01(num(w.cloud, DEFAULT_WEATHER.cloud)),
        rain: clamp01(num(w.rain, DEFAULT_WEATHER.rain)),
        snow: clamp01(num(w.snow, DEFAULT_WEATHER.snow)),
    };
}

function clamp01(v: number): number {
    return Math.min(1, Math.max(0, v));
}

/** Вектор ветра в мировых единицах/сек: сила 1 — 6 юнит/с. */
export function windVector(w: WeatherSpec): [number, number] {
    const s = w.windStrength * 6;
    return [Math.sin(w.windDir) * s, Math.cos(w.windDir) * s];
}

// ---- Параметры слоёв (юниты мира; окно — след кадра + маржа) ----

const RAIN_COUNT = 260; // капель при rain = 1
const RAIN_TOP = 40; // высота слоя дождя (вертикальный цикл капли)
const RAIN_SPEED = 22; // падение, юнит/с (ливень читается на 480×270)
const RAIN_SIZE = 0.5;
const RAIN_COLOR = '#a8bacb';
const RAIN_ALPHA = 0.7;

const SNOW_COUNT = 200; // хлопьев при snow = 1
const SNOW_TOP = 36;
const SNOW_SWAY = 1.2; // размах покачивания при падении
const SNOW_SIZE = 0.55;
const SNOW_COLOR = '#eef3f6';
const SNOW_ALPHA = 0.85;

const MARGIN = 16; // перекрытие за краем кадра (как у пепла)

/** Позы капель: якорь + падение + дрейф ветра (капля тяжёлая — дрейф ×0.6). */
export function rainPoints(
    spec: WeatherSpec, t: number,
    win: { minX: number; maxX: number; minZ: number; maxZ: number },
): { pos: [number, number, number]; alpha: number }[] {
    const n = Math.round(RAIN_COUNT * spec.rain);
    const [wx, wz] = windVector(spec);
    const out: { pos: [number, number, number]; alpha: number }[] = [];
    for (let i = 0; i < n; i++) {
        const speed = RAIN_SPEED + (i % 7) * 1.3; // разлёт скоростей — стена дождя
        const fall = RAIN_TOP - ((t * speed + i * 5.3) % RAIN_TOP);
        const x = wrapV(i * 37.7 + t * wx * 0.6, win.minX, win.maxX);
        const z = wrapV(i * 53.9 + t * wz * 0.6, win.minZ, win.maxZ);
        out.push({ pos: [x, fall, z], alpha: edge(win, x, z) * RAIN_ALPHA });
    }
    return out;
}

/** Позы снежинок: медленное падение с покачиванием + полный дрейф ветра. */
export function snowPoints(
    spec: WeatherSpec, t: number,
    win: { minX: number; maxX: number; minZ: number; maxZ: number },
): { pos: [number, number, number]; alpha: number }[] {
    const n = Math.round(SNOW_COUNT * spec.snow);
    const [wx, wz] = windVector(spec);
    const out: { pos: [number, number, number]; alpha: number }[] = [];
    for (let i = 0; i < n; i++) {
        const speed = 1.2 + (i % 5) * 0.3;
        const p = i * 2.399; // фазы покачивания — золотое сечение
        const fall = SNOW_TOP - ((t * speed + (i * 4.1) % SNOW_TOP) % SNOW_TOP);
        const sway = Math.sin(t * 0.8 + p) * SNOW_SWAY;
        const x = wrapV(i * 61.7 + t * wx + sway, win.minX, win.maxX);
        const z = wrapV(i * 47.3 + t * wz + Math.cos(t * 0.6 + p) * SNOW_SWAY * 0.6, win.minZ, win.maxZ);
        out.push({ pos: [x, fall, z], alpha: edge(win, x, z) * SNOW_ALPHA });
    }
    return out;
}

/** Заворачивание в окно (по одной оси). */
function wrapV(v: number, min: number, max: number): number {
    const size = max - min;
    let r = (v - min) % size;
    if (r < 0) r += size;
    return min + r;
}

/** Альфа у края окна: 0 в марже, 1 внутри кадра. */
function edge(win: { minX: number; maxX: number; minZ: number; maxZ: number }, x: number, z: number): number {
    const d = Math.min(x - win.minX, win.maxX - x, z - win.minZ, win.maxZ - z);
    return Math.max(0, Math.min(1, d / MARGIN));
}

/** Окно осадков: след кадра камеры по высоте слоя + маржа (едет за камерой). */
export function weatherWindow(
    renderer: Pick<VoxelRenderer, 'visibleWindow'>, top: number,
): { minX: number; maxX: number; minZ: number; maxZ: number } {
    const b = renderer.visibleWindow(0, top);
    return { minX: b.minX - MARGIN, maxX: b.maxX + MARGIN, minZ: b.minZ - MARGIN, maxZ: b.maxZ + MARGIN };
}

/** Погода: два слоя частиц (дождь/снег) + ветер внутри их дрейфа.
 *  Облачность уводит в VoxelRenderer.setCloud — система её не дублирует. */
export class WeatherSystem {
    private readonly renderer: VoxelRenderer;
    private readonly rain: ParticleLayer;
    private readonly snow: ParticleLayer;
    private spec: WeatherSpec = { ...DEFAULT_WEATHER };

    constructor(renderer: VoxelRenderer) {
        this.renderer = renderer;
        this.rain = renderer.addParticles();
        this.snow = renderer.addParticles();
    }

    /** Применить погоду (клампится). Облачность — сразу в рендер; дождь/снег
     *  отрисуются на ближайшем update(t). */
    set(spec: Partial<WeatherSpec>): void {
        this.spec = clampWeather(spec);
        this.renderer.setCloud(this.spec.cloud);
        if (this.spec.rain === 0 && this.spec.snow === 0) this.hide();
    }

    /** Активная спецификация (снапшот/мост). */
    get current(): WeatherSpec {
        return this.spec;
    }

    /** Тик: позы слоёв от времени цикла (детерминированно). */
    update(t: number): void {
        const win = weatherWindow(this.renderer, RAIN_TOP);
        const drops = rainPoints(this.spec, t, win);
        this.rain.update(drops.map((d) => ({ pos: d.pos, color: RAIN_COLOR, alpha: d.alpha, size: RAIN_SIZE })));
        const flakes = snowPoints(this.spec, t, win);
        this.snow.update(flakes.map((f) => ({ pos: f.pos, color: SNOW_COLOR, alpha: f.alpha, size: SNOW_SIZE })));
    }

    /** Тинт освещения: ночь гасит осадки вместе со сценой (как пепел/листья). */
    setTint(color: number): void {
        this.rain.setTint(color);
        this.snow.setTint(color);
    }

    /** Скрыть осадки (погода выключена). */
    hide(): void {
        this.rain.update([]);
        this.snow.update([]);
    }

    /** Счётчики для снапшота (фактически рисуемые капли/снежинки). */
    info(): { rainDrops: number; snowFlakes: number } {
        return {
            rainDrops: Math.round(RAIN_COUNT * this.spec.rain),
            snowFlakes: Math.round(SNOW_COUNT * this.spec.snow),
        };
    }

    dispose(): void {
        this.rain.dispose();
        this.snow.dispose();
    }
}