const test = require('node:test');
const assert = require('node:assert/strict');
const fs = require('fs');
const os = require('os');
const path = require('path');
const sharp = require('sharp');
require('../src/common');
const library = require('../src/web/lib/media/weather-icon-library');
const weatherIcons = require('../src/web/public/js/shared/weather-icons');
const vm = require('node:vm');
const placeholderContext = { window: {} };
vm.runInNewContext(fs.readFileSync(path.join(__dirname, '../src/web/public/js/shared/placeholder-utils.js'), 'utf8'), placeholderContext);
const placeholders = placeholderContext.window.placeholderUtils;

test('weather icon picker warns about each missing condition', function () {
  const source = fs.readFileSync(path.join(__dirname, '../src/web/public/js/settings/weather-icons.js'), 'utf8');
  assert.match(source, /window\.showToast\('Add images for: ' \+ labels\.join\(', '\) \+ '\.', 'warning'\)/);
  assert.match(source, /replace\(\/\^Upload\\s\+\|\\s\+icon\$\/g, ''\)/);
});

test('weather editor and player render day or night variants from one selected set', function () {
  const sets = [{ id: 'abc', name: 'Colour', icons: { clear: '/media/weather-icons/abc/clear-123abc.png' }, nightIcons: { clear: '/media/weather-icons/abc/night-clear-456def.png' } }];
  const location = { id: 1, responseJson: { current: { weather_code: 0, is_day: 1 } } };
  let editor;
  const editorContext = { window: { pulseWeatherIconSets: sets, pulseWeatherIcons: weatherIcons, placeholderUtils: placeholders,
    pulseRegionTypes: { register: function (_type, module) { editor = module; } } }, document: { addEventListener: function () {} } };
  vm.runInNewContext(fs.readFileSync(path.join(__dirname, '../src/web/public/js/regions/type/weather.js'), 'utf8'), editorContext);
  const region = { id: 1, region_key: 'weather', label: 'Forecast', baseStyle: '' };
  const content = { weather_location_id: 1, weather_icon_set_id: 'abc', value: '{{current.icon(48,24)}}' };
  const card = editor.renderEditorCard({ region: region, current: content, weatherLocations: [location] });
  assert.match(card, /name="region_weather_icon_set_id_1"/);
  assert.match(card, /value="abc" selected/);
  assert.match(card, /row g-3 align-items-end"><div class="col-12 col-lg-6"/);
  assert.match(card, /region_weather_forecast_mode_1"[^]*?region_weather_icon_set_id_1/);
  assert.doesNotMatch(card, /region_weather_night_icon_set_id_1/);
  sets[0].enabled = false;
  const disabledCard = editor.renderEditorCard({ region: region, current: content, weatherLocations: [location] });
  assert.match(disabledCard, /<option value="abc" selected>Colour<\/option>/);
  assert.doesNotMatch(disabledCard, /value="abc" selected disabled/);
  sets[0].enabled = true;
  const preview = editor.renderPreview(region, content, { weatherLocations: [location] });
  assert.match(preview, /clear-123abc.png/);
  assert.match(preview, /width:48px;height:24px/);
  const topPreview = editor.renderPreview(region, Object.assign({}, content, { value: '{{current.icon(48,96,top)}}' }), { weatherLocations: [location] });
  assert.match(topPreview, /vertical-align:top/);
  let player;
  const playerContext = { window: { pulseWeatherIcons: weatherIcons, placeholderUtils: placeholders,
    pulsePlayerRegionTypes: { register: function (_type, module) { player = module; } } },
    initialData: { weatherLocations: [location], weatherIconSets: sets }, escapeHtml: String, renderEditorJsContent: String };
  vm.runInNewContext(fs.readFileSync(path.join(__dirname, '../src/player/regions/weather.js'), 'utf8'), playerContext);
  assert.match(player.renderRegion(region, content), /clear-123abc.png/);
  assert.match(player.renderRegion(region, Object.assign({}, content, { value: '{{current.icon(48,96,bottom)}}' })), /vertical-align:bottom/);
  location.responseJson.current.is_day = 0;
  assert.match(player.renderRegion(region, content), /night-clear-456def.png/);
  location.responseJson.current.is_day = 1;
  assert.match(player.renderRegion(region, Object.assign({}, content, { weather_icon_set_id: '' })), /bi-sun/);
  location.responseJson.current.weather_code = 61;
  assert.match(player.renderRegion(region, content), /bi-cloud-rain/);
});

test('weather icons map exact WMO codes and fall back for missing or unsafe images', function () {
  assert.equal(weatherIcons.conditionForCode(3), 'overcast');
  assert.equal(weatherIcons.conditionForCode(85), 'snow');
  assert.equal(weatherIcons.conditionForCode(null), '');
  assert.equal(weatherIcons.conditionForCode(4), '');
  const sets = [{ id: 'abc', icons: { clear: '/media/weather-icons/abc/clear-123abc.png', rain: 'javascript:alert(1)' } }];
  assert.equal(weatherIcons.imageForCode(sets, 'abc', 0), sets[0].icons.clear);
  assert.equal(weatherIcons.imageForCode(sets, 'abc', 61), '');
  assert.equal(weatherIcons.imageForCode(sets, 'abc', 45), '');
  sets[0].enabled = false;
  assert.equal(weatherIcons.imageForCode(sets, 'abc', 0), sets[0].icons.clear);
  assert.match(weatherIcons.renderImage(sets[0].icons.clear, 48, 24), /width:48px;height:24px/);
  assert.match(weatherIcons.renderImage(sets[0].icons.clear, 48, 24), /display:inline-flex;vertical-align:middle;align-items:center;justify-content:center/);
  assert.match(weatherIcons.renderImage(sets[0].icons.clear, 48, 24), /vertical-align:middle.*line-height:0/);
  assert.match(weatherIcons.renderImage(sets[0].icons.clear, 48, 96, 'bottom'), /vertical-align:bottom/);
  assert.match(weatherIcons.renderImage(sets[0].icons.clear, 48, 24), /object-fit:contain/);
});

test('weather management template renders Assets and permission gated uploads', function () {
  const html = require('../src/web/view').renderView('settings/weather-icons/list', {
    title: 'Weather icons', active: 'weather-icons', assetsMenuOpen: true, conditions: library.CONDITIONS,
    sets: [], currentUser: { permissionKeys: ['weather-icons.read', 'weather-icons.create'] }
  });
  assert.match(html, /Weather icons/);
  assert.match(html, /<p>Assets/);
  assert.match(html, /nav-icon bi bi-folder2-open/);
  assert.ok(html.indexOf('User management') < html.indexOf('Assets'));
  assert.match(html, /action="\/settings\/weather-icons"/);
  assert.match(html, /name="icon_clear"/);
  assert.match(html, /class="page-header"/);
  assert.match(html, /Upload and manage shared icon sets for weather regions/);
  assert.match(html, /class="card card-outline card-primary mb-4 collapsed-card"/);
  assert.match(html, /class="card-title mb-0">Upload icon set/);
  assert.doesNotMatch(html, /Add a PNG or WebP image for every weather condition/);
  assert.match(html, /data-lte-toggle="card-collapse"/);
  assert.match(html, /data-lte-icon="expand"/);
  assert.match(html, /data-lte-icon="collapse"/);
  assert.match(html, /action="\/settings\/weather-icons" enctype="multipart\/form-data" class="card-body p-0"/);
  assert.match(html, /class="card-title">Managed icon sets/);
  assert.match(html, /data-table-sort-key="status">Status/);
  assert.equal((html.match(/class="app-content"/g) || []).length, 1);
  assert.doesNotMatch(html, /<details|<summary/);
  assert.match(html, /card-footer d-flex justify-content-end/);
  assert.match(html, /data-table-search-container data-table-pagination-card/);
  assert.match(html, /data-table-searchable/);
  assert.match(html, /data-table-search-empty-default/);
  assert.equal((html.match(/data-weather-icon-picker/g) || []).length, library.CONDITIONS.length * 2);
  assert.equal((html.match(/weather-icon-upload-row-label">Day icons/g) || []).length, 1);
  assert.equal((html.match(/Night icons <span>Optional/g) || []).length, 1);
  assert.match(html, /data-weather-icon-preview/);
  assert.match(html, /data-weather-icon-status>Required/);
  assert.match(html, /hidden aria-label="Clear icon" data-weather-icon-file/);
  assert.match(html, /accept="image\/png,image\/webp,image\/svg\+xml"/);
  assert.match(html, /data-weather-icon-set-form/);
});

test('weather management route paginates, sorts and preserves search state', async function () {
  const originalRead = library.readWeatherIconSets;
  const handlers = {};
  library.readWeatherIconSets = function () {
    return Array.from({ length: 30 }, function (_unused, index) {
      return { id: 'set-' + index, name: 'Set ' + String(index).padStart(2, '0'), icons: {} };
    });
  };
  try {
    require('../src/web/routes/settings/weather-icons')({
      get: function (url, ...callbacks) { handlers[url] = callbacks; },
      post: function () {}
    }, { mediaDir: 'media', pool: { query: async function () { return [[]]; } }, requirePermission: function () { return function () {}; } });
    const response = { status: function () { return this; }, send: function (html) { this.html = html; } };
    const currentUser = { permissionKeys: ['weather-icons.read', 'weather-icons.update'] };
    const fail = function (error) { throw error; };
    await handlers['/settings/weather-icons'][1]({ query: { page: '2', sort: 'name', direction: 'asc' }, currentUser: currentUser }, response, fail);
    assert.equal((response.html.match(/<tr data-table-search-row>/g) || []).length, 5);
    assert.match(response.html, /Set 25/);
    assert.doesNotMatch(response.html, /Set 00/);
    assert.match(response.html, /data-bs-toggle="modal"/);
    assert.match(response.html, /href="\/assets\/css\/weather-icons.css"/);
    await handlers['/settings/weather-icons'][1]({ query: { search: 'Set 29', page: '2' }, currentUser: currentUser }, response, fail);
    assert.equal((response.html.match(/<tr data-table-search-row>/g) || []).length, 1);
    assert.match(response.html, /Set 29/);
    await handlers['/settings/weather-icons'][1]({ query: { search: 'Set', page: '2' }, currentUser: currentUser }, response, fail);
    assert.match(response.html, /search(?:=|&#x3D;)Set/);
  } finally {
    library.readWeatherIconSets = originalRead;
  }
});

test('weather sets require every condition image and support replacement', async function () {
  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'weather-icons-'));
  try {
    const buffer = await sharp({ create: { width: 16, height: 16, channels: 4, background: '#ff0000' } }).png().toBuffer();
    const allFiles = library.CONDITIONS.map(function (condition) { return { fieldname: 'icon_' + condition.key, buffer: buffer }; });
    const svgBuffer = Buffer.from('<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><rect width="16" height="16" fill="#00f"><animate attributeName="fill" values="#00f;#0ff;#00f" dur="1s" repeatCount="indefinite"/></rect></svg>');
    await assert.rejects(library.saveWeatherIconSet(root, 'Partial', allFiles.slice(0, 2)), /every weather condition.*Overcast/);
    const first = await library.saveWeatherIconSet(root, 'Colour', allFiles);
    const second = await library.saveWeatherIconSet(root, 'Outline', allFiles);
    assert.notEqual(first.id, second.id);
    assert.equal(Object.keys(first.icons).length, library.CONDITIONS.length);
    assert.match(first.icons.clear, /^\/media\/assets\/weather-icons\//);
    const disabled = library.setWeatherIconSetEnabled(root, first.id, false);
    assert.equal(disabled.enabled, false);
    assert.equal(library.readWeatherIconSets(root).find(function (set) { return set.id === first.id; }).enabled, false);
    assert.ok(library.collectWeatherIconSyncOperations(root).some(function (operation) {
      return operation.type === 'put' && operation.uploadPath === first.icons.clear;
    }));
    assert.equal(fs.existsSync(path.join(root, 'assets', 'weather-icons', first.id, path.basename(first.icons.clear))), true);
    library.setWeatherIconSetEnabled(root, first.id, true);
    assert.equal(library.getWeatherManifestPath(root), path.join(root, 'assets', 'weather.json'));
    const svgSet = await library.saveWeatherIconSet(root, 'Vector', library.CONDITIONS.map(function (condition) { return { fieldname: 'icon_' + condition.key, buffer: svgBuffer }; }));
    const svgFileName = path.basename(svgSet.icons.clear);
    assert.match(svgFileName, /\.svg$/);
    assert.match(fs.readFileSync(path.join(root, 'assets', 'weather-icons', svgSet.id, svgFileName), 'utf8'), /<animate/);
    const replacementBuffer = await sharp({ create: { width: 16, height: 16, channels: 4, background: '#0000ff' } }).png().toBuffer();
    const updated = await library.saveWeatherIconSet(root, 'Colour updated', [{ fieldname: 'icon_snow', buffer: buffer }, { fieldname: 'night_icon_clear', buffer: replacementBuffer }], first.id);
    assert.equal(Object.keys(updated.icons).length, library.CONDITIONS.length);
    assert.match(updated.nightIcons.clear, /night-clear-/);
    assert.equal(library.readWeatherIconSets(root).length, 3);
    assert.deepEqual(library.collectWeatherIconRemovalOperations([first], [updated]), []);
    const replaced = await library.saveWeatherIconSet(root, 'Colour updated', [{ fieldname: 'icon_clear', buffer: replacementBuffer }], first.id);
    assert.deepEqual(library.collectWeatherIconRemovalOperations([updated], [replaced]), [{ type: 'delete', uploadPath: updated.icons.clear }]);
    const removed = library.deleteWeatherIconSet(root, second.id);
    const removalOperations = library.collectWeatherIconRemovalOperations([removed], []);
    assert.equal(removalOperations.length, library.CONDITIONS.length);
    assert.deepEqual(removalOperations.find(function (operation) { return operation.uploadPath === second.icons.snow; }), { type: 'delete', uploadPath: second.icons.snow });
    assert.equal(fs.existsSync(path.join(root, 'assets', 'weather-icons', second.id)), false);
    await assert.rejects(library.saveWeatherIconSet(root, 'Colour updated', []), /already exists/);
    await assert.rejects(library.saveWeatherIconSet(root, 'Invalid', allFiles.map(function (file, index) {
      return index === 0 ? { fieldname: file.fieldname, buffer: Buffer.from('not an image') } : file;
    })));
    await assert.rejects(library.saveWeatherIconSet(root, 'Unsafe SVG', library.CONDITIONS.map(function (condition) {
      return { fieldname: 'icon_' + condition.key, buffer: Buffer.from('<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><script>alert(1)</script></svg>') };
    })), /cannot contain scripts/);
    assert.equal(library.readWeatherIconSets(root).length, 2);
  } finally {
    fs.rmSync(root, { recursive: true, force: true });
  }
});

test('weather icon usage recognizes one set reference', function () {
  const content = { weather: { weather_icon_set_id: 'set' } };
  const isUsed = function (setId) {
    return Object.values(content).some(function (region) {
      return region && region.weather_icon_set_id === setId;
    });
  };
  assert.equal(isUsed('set'), true);
  assert.equal(isUsed('other'), false);
});