import Bowser from "bowser";
import type { SessionMetadataPayload } from "../models/AuthModels";

const LOCATION_TIMEOUT_MS = 2500;
const LOCATION_MAX_AGE_MS = 5 * 60 * 1000;
const LOCATION_CACHE_KEY = "dpz.auth.location.cache";
const LOCATION_CACHE_TTL_MS = 10 * 60 * 1000;

interface CachedLocation {
    latitude?: number;
    longitude?: number;
    locationAccuracy?: number;
    locationSource?: string;
    cachedAt: number;
}

let warmUpInFlight: Promise<void> | null = null;

export class SessionMetadataService {
    async collect(): Promise<SessionMetadataPayload> {
        const parser = Bowser.getParser(navigator.userAgent);
        const browser = parser.getBrowser();
        const os = parser.getOS();
        const platform = parser.getPlatform();
        const deviceType = platform.type || "desktop";

        return {
            deviceName: this.toDeviceName(browser.name, os.name, deviceType),
            deviceType,
            browserName: browser.name,
            browserVersion: browser.version,
            osName: os.name,
            osVersion: os.version,
            platform: platform.vendor || platform.model || platform.type,
            screenWidth: window.screen?.width,
            screenHeight: window.screen?.height,
            language: navigator.language,
            ...this.getCachedLocation(),
        };
    }

    warmUp(): void {
        if (typeof navigator === "undefined" || !("geolocation" in navigator)) {
            return;
        }

        if (warmUpInFlight !== null) {
            return;
        }

        warmUpInFlight = this.warmUpInternal().finally(() => {
            warmUpInFlight = null;
        });
    }

    private async warmUpInternal(): Promise<void> {
        try {
            if (this.isLocationCacheFresh()) {
                return;
            }

            const permission = await this.queryGeolocationPermission();
            if (permission === "denied") {
                return;
            }

            const location = await this.getBrowserLocation(true);
            this.saveLocationCache(location);
        } catch {
            // 预热失败静默忽略，登录时 collect() 会退化为仅静态信息
        }
    }

    private async queryGeolocationPermission(): Promise<PermissionState | null> {
        if (typeof navigator.permissions === "undefined") {
            return null;
        }

        try {
            const result = await navigator.permissions.query({ name: "geolocation" });
            return result.state;
        } catch {
            return null;
        }
    }

    private getCachedLocation(): Partial<SessionMetadataPayload> {
        const cached = this.readLocationCache();
        if (cached === null) {
            return {};
        }

        return {
            latitude: cached.latitude,
            longitude: cached.longitude,
            locationAccuracy: cached.locationAccuracy,
            locationSource: cached.locationSource,
        };
    }

    private isLocationCacheFresh(): boolean {
        const cached = this.readLocationCache();
        return (
            cached !== null &&
            typeof cached.cachedAt === "number" &&
            Date.now() - cached.cachedAt <= LOCATION_CACHE_TTL_MS
        );
    }

    private readLocationCache(): CachedLocation | null {
        try {
            const raw = window.localStorage.getItem(LOCATION_CACHE_KEY);
            if (raw === null) {
                return null;
            }

            const cached = JSON.parse(raw) as CachedLocation;
            if (
                typeof cached !== "object" ||
                cached === null ||
                typeof cached.cachedAt !== "number"
            ) {
                return null;
            }

            return cached;
        } catch {
            return null;
        }
    }

    private saveLocationCache(location: Partial<SessionMetadataPayload>): void {
        if (location.latitude === undefined || location.longitude === undefined) {
            return;
        }

        const cached: CachedLocation = {
            latitude: location.latitude,
            longitude: location.longitude,
            locationAccuracy: location.locationAccuracy,
            locationSource: location.locationSource,
            cachedAt: Date.now(),
        };

        try {
            window.localStorage.setItem(LOCATION_CACHE_KEY, JSON.stringify(cached));
        } catch {
            // 存储不可用时静默忽略
        }
    }

    private getBrowserLocation(waitForUser: boolean): Promise<Partial<SessionMetadataPayload>> {
        if (!("geolocation" in navigator)) {
            return Promise.resolve({});
        }

        const timeoutMs = waitForUser ? 0 : LOCATION_TIMEOUT_MS;

        return new Promise((resolve) => {
            let settled = false;
            const finish = (value: Partial<SessionMetadataPayload>) => {
                if (settled) {
                    return;
                }

                settled = true;
                resolve(value);
            };

            let timer = 0;
            if (timeoutMs > 0) {
                timer = window.setTimeout(() => finish({}), timeoutMs);
            }

            navigator.geolocation.getCurrentPosition(
                (position) => {
                    if (timer > 0) {
                        window.clearTimeout(timer);
                    }
                    finish({
                        latitude: position.coords.latitude,
                        longitude: position.coords.longitude,
                        locationAccuracy: position.coords.accuracy,
                        locationSource: "browser",
                    });
                },
                () => {
                    if (timer > 0) {
                        window.clearTimeout(timer);
                    }
                    finish({});
                },
                {
                    enableHighAccuracy: false,
                    maximumAge: LOCATION_MAX_AGE_MS,
                    timeout: timeoutMs > 0 ? timeoutMs : undefined,
                },
            );
        });
    }

    private toDeviceName(
        browserName: string | undefined,
        osName: string | undefined,
        deviceType: string,
    ) {
        const browser = browserName || "Browser";
        const os = osName || this.toDeviceTypeName(deviceType);
        return `${os} · ${browser}`;
    }

    private toDeviceTypeName(deviceType: string) {
        switch (deviceType) {
            case "mobile":
                return "Mobile";
            case "tablet":
                return "Tablet";
            case "tv":
                return "TV";
            default:
                return "Desktop";
        }
    }
}