'use strict';
'require baseclass';
'require rpc';
'require uci';
'require view.dashboard.lib.charts as charts';
'require view.dashboard.lib.history as history';

const read = rpc.declare({ object: 'luci.dashboard.temperature', method: 'read', params: [ 'since', 'id' ], expect: { '': {} } });
const temperature = value => Number.isFinite(value) ? '%.1f °C'.format(value) : '—';
const STEP = 10000, DEFAULT_LINES = 8, MAX_LINES = 64;

function sensorCategory(sensor, components) {
	return typeof components[sensor.category] == 'string' ? sensor.category : 'other';
}

// Rebuild only when sensor metadata changes. Number channels within their
// component, keeping existing numbers when sources reorder or disappear.
// These are sensor labels, not inferred radio bands or physical port numbers.
function nameChannels(channels, components) {
	const groups = new Map();
	for (const channel of channels.values()) {
		const group = groups.get(channel.category) || { count: 0, last: 0, numbered: false };
		group.count++;
		group.last = Math.max(group.last, channel.number || 0);
		group.numbered ||= channel.numbered;
		groups.set(channel.category, group);
	}
	for (const [, channel] of Array.from(channels).sort(([a], [b]) => a.localeCompare(b, undefined, { numeric: true }))) {
		const group = groups.get(channel.category);
		channel.number ||= ++group.last;
		channel.numbered = group.count > 1 || group.numbered;
		channel.name = components[channel.category] + (channel.numbered ? ' ' + channel.number : '');
	}
}

function colorChannels(channels) {
	const used = new Set(Array.from(channels.values(), channel => channel.color));
	let color = 1;
	for (const channel of channels.values())
		if (!channel.color) {
			while (used.has(color))
				color++;
			if (color > MAX_LINES)
				break;
			channel.color = color;
			used.add(color++);
		}
}

function channelColor(channel) {
	return channel.color > 8
		? 'hsl(%d, 60%%, var(--dashboard-extra-lightness))'.format((channel.color * 137.508) % 360) : null;
}

// CPU selection priorities come from the same registry as component names.
// Never switch channels merely because the preferred sensor failed a read.
function processorSensor(sensors) {
	let selected, priority = 99;
	for (const sensor of sensors) {
		const value = sensor.category == 'cpu'
			? (Number.isFinite(sensor.priority) ? sensor.priority : 8) : 99;
		if (value < priority || (selected && value == priority &&
		    (sensor.id || sensor.label).localeCompare(selected.id || selected.label, undefined, { numeric: true }) < 0)) {
			selected = sensor;
			priority = value;
		}
	}
	return selected;
}

// A module may expose multiple radios or thermal zones. Keep all channels in
// details, and summarize the hottest available reading for each component.
function componentTemperature(sensors, category, label) {
	let present = false, value = -Infinity;
	for (const sensor of sensors)
		if (sensor.category == category) {
			present = true;
			if (Number.isFinite(sensor.celsius))
				value = Math.max(value, sensor.celsius);
		}
	// Wrap between components, keeping each label and reading together.
	return present ? '%s\u00a0%s'.format(label, temperature(value).replace(' ', '\u00a0')) : null;
}

return baseclass.extend({
	widgets: [
		{ id: 'temperature', slot: 'cards', title: _('Temperature'), order: 40 },
		{ id: 'temperature_history', slot: 'charts', title: _('Temperature history'), order: 30 },
		{ id: 'temperatures', slot: 'tabs', title: _('Temperatures'), order: 40 }
	],

	// All views share channel identities, even when the history chart is hidden
	// or settings are opened first. Selection never changes sensor numbering.
	syncChannels(data) {
		let dirty = false;
		if (data.components && typeof data.components == 'object' && !Array.isArray(data.components)) {
			const components = { other: _('Sensor'), ...Object.fromEntries(Object.entries(data.components)
				.filter(([, label]) => typeof label == 'string').map(([id, label]) => [id, _(label)])) };
			dirty = JSON.stringify(components) !== JSON.stringify(this.components);
			this.components = components;
		}
		const components = this.components ||= { other: _('Sensor') };
		const sensors = Array.isArray(data.sensors) ? data.sensors : [];
		const channels = this.channels ||= new Map();
		const current = new Map(sensors.slice(0, MAX_LINES).map((sensor, index) => [ sensor.id, { sensor, index } ]));
		for (const [id] of channels)
			if (!current.has(id)) {
				channels.delete(id);
				dirty = true;
			}
		for (const [id, { sensor, index }] of current) {
			let channel = channels.get(id);
			if (!channel) {
				channel = { color: 0 };
				channels.set(id, channel);
				dirty = true;
			}
			if (channel.label !== sensor.label || channel.index !== index)
				dirty = true;
			const category = sensorCategory(sensor, components);
			if (channel.category !== category) {
				channel.category = category;
				channel.number = 0;
				channel.numbered = false;
				dirty = true;
			}
			channel.label = sensor.label;
			channel.index = index;
			channel.current = sensor.celsius;
		}
		if (dirty) {
			nameChannels(channels, components);
			colorChannels(channels);
			if (this.trend)
				this.trend.dirty = true;
		}
		return channels;
	},

	load() {
		const now = performance.now();
		const state = this.history ||= { samples: [], step: STEP, slots: 30, now: 0 };
		if (this.pending)
			return this.pending;
		if (this.data && now < this.nextRead) {
			this.data.age_ms = this.age == null ? null : this.age + now - this.received;
			state.now = this.receivedNow + now - this.received;
			return Promise.resolve(this.data);
		}

		// Match backend sampling and fetch only new rows after the first load.
		const last = state.samples[state.samples.length - 1];
		this.pending = L.resolveDefault(read(last ? last[0] : 0, state.id || ''), { status: 'error', sensors: [] }).then(data => {
			history.update(state, data);
			this.data = data;
			this.received = performance.now();
			this.receivedNow = state.now;
			this.age = Number.isFinite(data.age_ms) ? data.age_ms : null;
			this.nextRead = this.received + (data.status == 'unsupported' ? 60000
				: this.age != null && this.age < state.step ? state.step - this.age : state.step);
			this.pending = null;
			return data;
		});
		return this.pending;
	},

	// The layout form calls this only when opened; normal charts do not load
	// the form library or build any configuration controls.
	addOptions(section, form, ui) {
		return this.load().then(data => {
			const channels = this.syncChannels(data);
			const o = section.option(form.MultiValue, 'temperature_sensors', _('Temperature history'));
			o.retain = true;
			o.forcewrite = true;
			o.depends({ charts: 'temperature_history', '!contains': true });
			o.cfgvalue = () => {
				const selected = L.toArray(uci.get('dashboard', 'layout', 'temperature_sensors'));
				return selected.length ? selected : Array.from(channels.keys()).slice(0, DEFAULT_LINES);
			};
			for (const [id, channel] of channels)
				o.value(id, E('span', { 'class': 'dashboard-sensor-choice', 'title': channel.label }, [
					E('i', { 'class': 'dashboard-series-' + channel.color,
						'style': channelColor(channel) ? 'background-color:' + channelColor(channel) : null,
						'aria-hidden': 'true' }), channel.name
				]));
			// Keep saved IDs selectable even if a device is temporarily absent.
			for (const id of L.toArray(uci.get('dashboard', 'layout', 'temperature_sensors')))
				if (!channels.has(id))
					o.value(id, '%s · %s'.format(_('Unavailable'), id));
			o.validate = (section_id, value) => !L.toArray(value).length ? _('Select at least one sensor.')
				: L.toArray(value).length <= MAX_LINES || _('Select no more than %d sensors.').format(MAX_LINES);
			o.renderWidget = function(section_id, option_index, cfgvalue) {
				const widget = new ui.Select(L.toArray(cfgvalue), this.transformChoices(), {
					id: this.cbid(section_id), sort: this.keylist, multiple: true,
					widget: 'checkbox', orientation: 'vertical',
					validate: this.getValidator(section_id), disabled: this.map.readonly
				});
				// ui.Select renders checkboxes but its default accessors handle radios.
				widget.getValue = function() {
					return Array.from(this.node.querySelectorAll('input:checked'), input => input.value);
				};
				widget.setValue = function(value) {
					const selected = new Set(L.toArray(value));
					this.node.querySelectorAll('input').forEach(input => input.checked = selected.has(input.value));
				};
				return widget.render();
			};
			return { slot: 'charts', widget: 'temperature_history', title: _('Temperature history'), options: [ o ] };
		});
	},

	renderChart(data, sensors) {
		const channels = this.syncChannels(data);
		const state = this.history;
		const span = history.span(state);
		const fresh = !state.failed && Number.isFinite(data.age_ms) && data.age_ms < 15000
			&& (data.status == 'ok' || data.status == 'partial');
		let h = this.trend;
		if (!h) {
			h = this.trend = {
				channels, min: 0, max: 100,
				selected: new Set(L.toArray(uci.get('dashboard', 'layout', 'temperature_sensors')).slice(0, MAX_LINES)),
				plot: E('div'), legend: E('div'), message: charts.empty('')
			};
			h.node = charts.card({ title: _('Temperature history'), desc: '°C', body: [ h.plot, h.legend, h.message ] });
		}

		if (h.id !== state.id) {
			h.id = state.id;
			h.min = 0;
			h.max = 100;
			h.dirty = true;
		}
		const tick = Math.floor(performance.now() / state.step);
		const last = state.samples[state.samples.length - 1]?.[0] || 0;
		if (!h.dirty && h.tick === tick && h.drawn === last && h.fresh === fresh)
			return h.node;
		h.dirty = false;
		h.tick = tick;
		h.drawn = last;
		h.fresh = fresh;

		const series = [], legend = [];
		const selected = h.selected.size ? h.selected : new Set(sensors.slice(0, DEFAULT_LINES).map(sensor => sensor.id));
		for (const [id, channel] of h.channels) {
			if (!channel.color || !selected.has(id))
				continue;
			const values = history.series(cur => cur[1] > state.now - span * 1000 ? cur[2][channel.index] : null, state.samples, state.step);
			for (const point of values)
				if (Number.isFinite(point.v)) {
					h.min = Math.min(h.min, Math.floor(point.v / 20) * 20);
					h.max = Math.max(h.max, Math.ceil(point.v / 20) * 20);
				}
			const className = 'dashboard-series-' + channel.color;
			const color = channelColor(channel);
			series.push({ className, color, values });
			legend.push({ className, color, label: channel.name, title: channel.label, value: temperature(fresh ? channel.current : null) });
		}
		h.lines = charts.lines({ node: h.lines, end: state.now, span, min: h.min, max: h.max,
			ticks: [ 0, 1, 2, 3, 4 ].map(i => {
				const value = h.min + (h.max - h.min) * i / 4;
				return { value, label: String(value) };
			}), ariaLabel: _('Temperature history'), series });
		if (h.plot.firstChild !== h.lines)
			L.dom.content(h.plot, h.lines);
		L.dom.content(h.legend, charts.legend(legend));
		h.message.textContent = !fresh ? _('Temperature temporarily unavailable')
			: !series.length ? _('Selected temperature sensors are unavailable') : '';
		return h.node;
	},

	render(data) {
		const age = data.age_ms >= 15000 ? Math.floor(data.age_ms / 1000) : 0;
		if (data === this.renderedData && age === this.renderedAge)
			return this.sections;
		this.renderedData = data;
		this.renderedAge = age;
		const sensors = Array.isArray(data.sensors) ? data.sensors : [];
		const channels = this.syncChannels(data);
		const components = this.components;
		const processor = processorSensor(sensors);
		const value = processor?.celsius;
		const message = data.status == 'unsupported' ? _('No supported temperature sensors found') : _('Temperature temporarily unavailable');
		const stale = data.age_ms >= 15000;
		const modules = ['nss', 'wifi', 'modem'].map(category => componentTemperature(sensors, category, components[category] || components.other)).filter(Boolean);
		const sub = [];
		for (let i = 0; i < modules.length; i += 2)
			sub.push(modules.slice(i, i + 2).join(' · '));
		if (!processor)
			sub.push(_('Processor temperature unavailable'));
		else if (!Number.isFinite(value))
			sub.push(message);
		if (stale)
			sub.push(_('Reading age: %d seconds').format(Math.floor(data.age_ms / 1000)));

		let card, tab;
		if (data.status == 'unsupported')
			this.trend = null;
		return this.sections = {
			cards: data.status == 'unsupported' ? [] : [{
				id: 'temperature', node: () => card ||= charts.kpi({
					icon: 'temperature', title: _('Temperature'), className: 'dashboard-temperature',
					value: [ '%s %s'.format(components.cpu || _('CPU'), temperature(value)) ], sub, stacked: true
				})
			}],
			charts: data.status == 'unsupported' ? [] : [{
				id: 'temperature_history', node: () => this.renderChart(data, sensors)
			}],
			tabs: data.status == 'unsupported' ? [] : [{ id: 'temperatures', title: _('Temperatures'), content: () => tab ||= E('div', {}, [
				stale ? E('p', {}, [ _('Reading age: %d seconds').format(Math.floor(data.age_ms / 1000)) ]) : '',
				data.status == 'partial' ? E('p', {}, [ _('Some temperature sensors are unavailable') ]) : '',
				sensors.length ? charts.table({
					head: [ _('Component'), _('Sensor'), _('Temperature') ],
					rows: sensors.map(s => [ channels.get(s.id)?.name || components[sensorCategory(s, components)], s.label, temperature(s.celsius) ])
				}) : charts.empty(message)
			]) }]
		};
	}
});