<?php
declare(strict_types=1);

final class NiroTelemetrySnapshot
{
    private const DEFAULT_CONFIG = '/volume1/web/config/car-mqtt.php';
    private const MAX_PACKET_BYTES = 524288;

    public static function dashboard(): array
    {
        $config = self::config();
        if ($config === null) {
            return [
                'configured' => false,
                'available' => false,
                'message' => 'MQTT 모니터 설정이 없습니다.',
            ];
        }

        try {
            $snapshot = self::cachedSnapshot($config);
            return self::summarize($snapshot, $config);
        } catch (Throwable $e) {
            return [
                'configured' => true,
                'available' => false,
                'message' => '차량 텔레메트리를 불러오지 못했습니다.',
            ];
        }
    }

    public static function summarize(array $snapshot, array $config = []): array
    {
        $state = is_array($snapshot['state'] ?? null) ? $snapshot['state'] : [];
        $sampleEpoch = self::integer($state['_sample_epoch'] ?? 0);
        $age = $sampleEpoch > 0 ? max(0, time() - $sampleEpoch) : null;
        $staleAfter = max(10, (int)($config['stale_after'] ?? 20));
        $serviceTotal = 0;
        $serviceAvailable = 0;

        foreach ($state as $key => $value) {
            if (!str_starts_with((string)$key, 'meta_') || !str_ends_with((string)$key, '_dumpsys_ok')) {
                continue;
            }
            $serviceTotal++;
            if ((string)$value === 'true') {
                $serviceAvailable++;
            }
        }

        $keyMap = [
            'ignition' => 'system_root_ign',
            'reverse' => 'system_root_reverse',
            'parking' => 'system_root_parking',
            // The IndividualDriveMode block is a persisted/default structure on
            // V038.  Its Vehicle Speed and Gear Status stay at 0/P while the car
            // is moving.  The root fields are the live MICOM callbacks.
            'gear' => 'system_root_gear',
            'speed' => 'system_root_speed',
            'previous_speed' => 'system_root_prevspeed',
            'parking_brake' => 'system_root_mparkingbrakestatus',
            'camera' => 'system_individualdrivemode_fron_rear_camera_status',
            'drive_mode' => 'system_individualdrivemode_mcurrentdrivemode',
            'fuel_warning' => 'system_root_fuelwarning',
            'distance_to_empty' => 'system_individualdrivemode_distance_to_empty',
            'battery_soc_12v' => 'system_root_mbatterysoc',
            'battery_above_60' => 'system_root_mbattery60above',
            'ldc_battery' => 'system_root_ldcbatterystate',
            'hev_mode' => 'hev_micom_hevstatus_mhevsystemmode',
            'hev_charge_state' => 'hev_micom_hevstatus_mchargestate',
            'motor_usage' => 'hev_micom_hevstatus_melectricmotorusage',
            'ldc_12v_charge' => 'hev_micom_hevstatus_cf_ldc_12vcharge',
            'odometer_raw' => 'hev_micom_hevstatus_odometer',
            'driver_unlock' => 'bcm_micom_bcmstatus_mdrvunlockstate',
            'passenger_unlock' => 'bcm_micom_bcmstatus_mpasunlockstate',
            'rear_left_unlock' => 'bcm_micom_bcmstatus_mrlunlockstate',
            'rear_right_unlock' => 'bcm_micom_bcmstatus_mrrunlockstate',
            'driver_door' => 'bcm_micom_bcmstatus_mdrvopenedstate',
            'passenger_door' => 'bcm_micom_bcmstatus_mpasopenedstate',
            'rear_left_door' => 'bcm_micom_bcmstatus_mrlopenedstate',
            'rear_right_door' => 'bcm_micom_bcmstatus_mrropenedstate',
            'trunk' => 'bcm_micom_bcmstatus_mtrunkopenedstate',
            'lock_state' => 'bcm_micom_bcmstatus_mlockstate',
            'hazard' => 'bcm_micom_bcmstatus_mlamphazard',
            'head_lamp' => 'bcm_micom_bcmstatus_mlamphead',
            'tail_lamp' => 'bcm_micom_bcmstatus_mlamptail',
            'fog_lamp' => 'bcm_micom_bcmstatus_mlampfog',
            'driver_seatbelt' => 'bcm_micom_bcmstatus_mdrvseatbelt',
            'passenger_seatbelt' => 'bcm_micom_bcmstatus_mpasseatbelt',
            'airbag' => 'bcm_micom_bcmstatus_mairbagstate',
            'climate_on' => 'datc_micom_datcstatus_mopstatus',
            'air_conditioner' => 'datc_micom_datcstatus_maconoff',
            'climate_auto' => 'datc_micom_datcstatus_mauto',
            'climate_dual' => 'datc_micom_datcstatus_mdual',
            'driver_temperature' => 'datc_micom_datcstatus_mdrtempc',
            'passenger_temperature' => 'datc_micom_datcstatus_mpstempc',
            'outside_temperature' => 'datc_micom_datcstatus_mambienttempc',
            'blower_level' => 'datc_micom_datcstatus_mmainblowerlevel',
            'intake_mode' => 'datc_micom_datcstatus_mintake',
            'co2_warning' => 'datc_micom_datcstatus_mco2warning',
            'route_guide' => 'system_individualdrivemode_route_guide',
            'next_turn_distance' => 'cluster_tbt_subinfo_distance',
            'speed_limit' => 'cluster_slif_navi_info_speed_limit',
            'off_route' => 'cluster_scc_hu_p_info_offroutestatus',
            'camera_distance' => 'cluster_scc_hu_p_info_rangecamdist',
            'camera_speed_limit' => 'cluster_scc_hu_p_info_rangecamspdlimit',
            'av_power' => 'power_root_av_power_status',
            'head_unit_power' => 'power_root_power_status',
            'audio_mode' => 'mode_root_current_mode_real',
            'audio_focus' => 'mode_root_modemanager_has_audiofocus',
            'audio_volume' => 'system_individualdrivemode_last_main_volume',
            'mute' => 'system_individualdrivemode_mute_status',
            'micom_connected' => 'system_root_micom_connected',
            'boot_completed' => 'system_root_boot_completed',
            'boot_sequence_finished' => 'system_root_bootsequence_finished',
            'wireless_charging' => 'system_root_wirelesscharing',
            'dtc_warning' => 'system_individualdrivemode_dtc_warning',
            'pdw_front_left' => 'system_individualdrivemode_pdw_fl',
            'pdw_front_right' => 'system_individualdrivemode_pdw_fr',
            'pdw_rear_left' => 'system_individualdrivemode_pdw_rl',
            'pdw_rear_right' => 'system_individualdrivemode_pdw_rr',
        ];

        $metrics = [];
        foreach ($keyMap as $name => $key) {
            $value = array_key_exists($key, $state) ? (string)$state[$key] : null;
            $metrics[$name] = [
                'value' => $value,
                'supported' => $value !== null && !self::unsupported($value),
            ];
        }

        return [
            'configured' => true,
            'available' => $state !== [],
            'online' => (string)($snapshot['availability'] ?? '') === 'online',
            'stale' => $age === null || $age > $staleAfter,
            'age_seconds' => $age,
            'sample_epoch' => $sampleEpoch,
            'metric_count' => max(0, count($state) - (array_key_exists('_sample_epoch', $state) ? 1 : 0)),
            'services' => [
                'available' => $serviceAvailable,
                'total' => $serviceTotal,
            ],
            'cache' => [
                'received_at' => (int)($snapshot['received_at'] ?? 0),
                'fallback' => !empty($snapshot['cache_fallback']),
            ],
            'metrics' => $metrics,
        ];
    }

    private static function config(): ?array
    {
        $path = getenv('NIRO_CAR_MQTT_CONFIG') ?: self::DEFAULT_CONFIG;
        if (!is_file($path) || is_link($path)) {
            return null;
        }
        $config = require $path;
        if (!is_array($config)) {
            return null;
        }
        foreach (['host', 'username', 'password'] as $required) {
            if (!isset($config[$required]) || trim((string)$config[$required]) === '') {
                return null;
            }
        }
        return $config;
    }

    private static function cachedSnapshot(array $config): array
    {
        $cachePath = (string)($config['cache_path'] ?? sys_get_temp_dir() . '/niro-car-mqtt-state.json');
        $cacheTtl = max(1, min(15, (int)($config['cache_ttl'] ?? 4)));
        $cached = self::readCache($cachePath);
        if ($cached !== null && (time() - (int)($cached['received_at'] ?? 0)) <= $cacheTtl) {
            return $cached;
        }

        $lock = fopen($cachePath . '.lock', 'c');
        if ($lock === false) {
            throw new RuntimeException('cache_lock_open_failed');
        }
        try {
            if (!flock($lock, LOCK_EX)) {
                throw new RuntimeException('cache_lock_failed');
            }
            $cached = self::readCache($cachePath);
            if ($cached !== null && (time() - (int)($cached['received_at'] ?? 0)) <= $cacheTtl) {
                return $cached;
            }
            try {
                $fresh = self::fetch($config);
                self::writeCache($cachePath, $fresh);
                return $fresh;
            } catch (Throwable $e) {
                if ($cached !== null) {
                    $cached['cache_fallback'] = true;
                    return $cached;
                }
                throw $e;
            }
        } finally {
            flock($lock, LOCK_UN);
            fclose($lock);
        }
    }

    private static function fetch(array $config): array
    {
        $host = trim((string)$config['host']);
        $port = max(1, min(65535, (int)($config['port'] ?? 1883)));
        $timeout = max(0.5, min(5.0, (float)($config['timeout'] ?? 2.0)));
        $stateTopic = (string)($config['state_topic'] ?? 'niro/gen5w/state');
        $availabilityTopic = (string)($config['availability_topic'] ?? 'niro/gen5w/status');
        $connection = self::openConnection($config, $host, $port, $timeout);
        $reader = $connection['reader'];
        $writer = $connection['writer'];

        try {
            $clientId = 'car-dashboard-' . getmypid() . '-' . bin2hex(random_bytes(4));
            $variable = self::mqttString('MQTT') . chr(4) . chr(0xC2) . pack('n', 10);
            $payload = self::mqttString($clientId)
                . self::mqttString((string)$config['username'])
                . self::mqttString((string)$config['password']);
            self::writePacket($writer, 0x10, $variable . $payload);
            $connAck = self::readPacket($reader);
            if (($connAck['type'] ?? 0) !== 2 || strlen((string)$connAck['payload']) !== 2
                || ord($connAck['payload'][1]) !== 0) {
                throw new RuntimeException('mqtt_connack_failed_'
                    . (int)($connAck['type'] ?? 0) . '_'
                    . bin2hex((string)($connAck['payload'] ?? '')));
            }

            $subscribe = pack('n', 1)
                . self::mqttString($stateTopic) . chr(0)
                . self::mqttString($availabilityTopic) . chr(0);
            self::writePacket($writer, 0x82, $subscribe);

            $state = null;
            $availability = null;
            $deadline = microtime(true) + $timeout;
            while (microtime(true) < $deadline && ($state === null || $availability === null)) {
                $packet = self::readPacket($reader);
                if (($packet['type'] ?? 0) !== 3) {
                    continue;
                }
                [$topic, $body] = self::publishBody((string)$packet['payload'], (int)($packet['flags'] ?? 0));
                if ($topic === $stateTopic) {
                    $decoded = json_decode($body, true, 512, JSON_THROW_ON_ERROR);
                    if (!is_array($decoded)) {
                        throw new RuntimeException('mqtt_state_not_object');
                    }
                    $state = $decoded;
                } elseif ($topic === $availabilityTopic) {
                    $availability = trim($body);
                }
            }

            if (!is_array($state)) {
                throw new RuntimeException('mqtt_state_missing');
            }

            return [
                'received_at' => time(),
                'availability' => $availability ?? 'unknown',
                'state' => $state,
            ];
        } finally {
            self::closeConnection($connection);
        }
    }

    private static function openConnection(array $config, string $host, int $port, float $timeout): array
    {
        $transport = (string)($config['transport'] ?? 'tcp');
        if ($transport === 'tailscale_nc') {
            if (preg_match('/^[A-Za-z0-9._-]+$/', $host) !== 1) {
                throw new RuntimeException('tailscale_host_invalid');
            }
            $binary = (string)($config['tailscale_binary'] ?? '/var/packages/Tailscale/target/bin/tailscale');
            if (!is_file($binary) || !is_executable($binary)) {
                throw new RuntimeException('tailscale_binary_unavailable');
            }
            $descriptors = [
                0 => ['pipe', 'r'],
                1 => ['pipe', 'w'],
                2 => ['file', '/dev/null', 'a'],
            ];
            $pipes = [];
            $process = proc_open([$binary, 'nc', $host, (string)$port], $descriptors, $pipes, null, null, [
                'bypass_shell' => true,
            ]);
            if (!is_resource($process) || count($pipes) < 2) {
                throw new RuntimeException('tailscale_nc_failed');
            }
            stream_set_timeout($pipes[0], (int)ceil($timeout));
            stream_set_timeout($pipes[1], (int)ceil($timeout));
            return [
                'reader' => $pipes[1],
                'writer' => $pipes[0],
                'process' => $process,
                'pipes' => $pipes,
            ];
        }

        if ($transport !== 'tcp') {
            throw new RuntimeException('mqtt_transport_invalid');
        }
        $errno = 0;
        $errstr = '';
        $socket = @stream_socket_client("tcp://{$host}:{$port}", $errno, $errstr, $timeout);
        if (!is_resource($socket)) {
            throw new RuntimeException('mqtt_connect_failed');
        }
        stream_set_timeout($socket, (int)ceil($timeout));
        return [
            'reader' => $socket,
            'writer' => $socket,
            'process' => null,
            'pipes' => [$socket],
        ];
    }

    private static function closeConnection(array $connection): void
    {
        $closed = [];
        foreach ((array)($connection['pipes'] ?? []) as $pipe) {
            if (!is_resource($pipe)) {
                continue;
            }
            $id = (int)$pipe;
            if (isset($closed[$id])) {
                continue;
            }
            fclose($pipe);
            $closed[$id] = true;
        }
        if (is_resource($connection['process'] ?? null)) {
            proc_terminate($connection['process']);
            proc_close($connection['process']);
        }
    }

    private static function publishBody(string $payload, int $flags): array
    {
        if (strlen($payload) < 2) {
            throw new RuntimeException('mqtt_publish_short');
        }
        $topicLength = unpack('n', substr($payload, 0, 2))[1];
        if ($topicLength < 1 || strlen($payload) < 2 + $topicLength) {
            throw new RuntimeException('mqtt_publish_topic_invalid');
        }
        $offset = 2 + $topicLength;
        $qos = ($flags >> 1) & 0x03;
        if ($qos > 0) {
            $offset += 2;
        }
        if (strlen($payload) < $offset) {
            throw new RuntimeException('mqtt_publish_payload_invalid');
        }
        return [substr($payload, 2, $topicLength), substr($payload, $offset)];
    }

    private static function writePacket($socket, int $header, string $payload): void
    {
        $packet = chr($header) . self::remainingLength(strlen($payload)) . $payload;
        $written = 0;
        $length = strlen($packet);
        while ($written < $length) {
            $count = fwrite($socket, substr($packet, $written));
            if ($count === false || $count === 0) {
                throw new RuntimeException('mqtt_write_failed');
            }
            $written += $count;
        }
    }

    private static function readPacket($socket): array
    {
        $first = self::readExact($socket, 1);
        $remaining = 0;
        $multiplier = 1;
        do {
            $digit = ord(self::readExact($socket, 1));
            $remaining += ($digit & 127) * $multiplier;
            $multiplier *= 128;
            if ($multiplier > 128 * 128 * 128 * 128) {
                throw new RuntimeException('mqtt_remaining_length_invalid');
            }
        } while (($digit & 128) !== 0);
        if ($remaining > self::MAX_PACKET_BYTES) {
            throw new RuntimeException('mqtt_packet_too_large');
        }
        $header = ord($first);
        return [
            'type' => $header >> 4,
            'flags' => $header & 0x0f,
            'payload' => self::readExact($socket, $remaining),
        ];
    }

    private static function readExact($socket, int $length): string
    {
        $buffer = '';
        while (strlen($buffer) < $length) {
            $chunk = fread($socket, $length - strlen($buffer));
            if ($chunk === false || $chunk === '') {
                $meta = stream_get_meta_data($socket);
                throw new RuntimeException(!empty($meta['timed_out']) ? 'mqtt_read_timeout' : 'mqtt_read_failed');
            }
            $buffer .= $chunk;
        }
        return $buffer;
    }

    private static function mqttString(string $value): string
    {
        if (strlen($value) > 65535) {
            throw new RuntimeException('mqtt_string_too_long');
        }
        return pack('n', strlen($value)) . $value;
    }

    private static function remainingLength(int $length): string
    {
        $encoded = '';
        do {
            $digit = $length % 128;
            $length = intdiv($length, 128);
            if ($length > 0) {
                $digit |= 128;
            }
            $encoded .= chr($digit);
        } while ($length > 0);
        return $encoded;
    }

    private static function readCache(string $path): ?array
    {
        if (!is_file($path) || filesize($path) > self::MAX_PACKET_BYTES * 2) {
            return null;
        }
        $decoded = json_decode((string)file_get_contents($path), true);
        return is_array($decoded) && is_array($decoded['state'] ?? null) ? $decoded : null;
    }

    private static function writeCache(string $path, array $snapshot): void
    {
        $json = json_encode($snapshot, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR);
        $temporary = $path . '.new.' . getmypid();
        if (file_put_contents($temporary, $json, LOCK_EX) === false) {
            throw new RuntimeException('cache_write_failed');
        }
        chmod($temporary, 0600);
        if (!rename($temporary, $path)) {
            @unlink($temporary);
            throw new RuntimeException('cache_replace_failed');
        }
    }

    private static function unsupported(string $value): bool
    {
        return in_array(trim($value), ['-1', '255', '65535', '4294967295', '0xff', '0xffffffff'], true);
    }

    private static function integer(mixed $value): int
    {
        return is_numeric($value) ? (int)$value : 0;
    }
}