import { defineStore } from "pinia";
import Storage from "@/utils/Storage";

const SETTING_STORAGE_KEY = "timi-server.setting";

export type ConnectProtocol = "http" | "https";

export interface ConnectSetting {
	protocol: ConnectProtocol;
	host: string;
	port: string;
	token: string;
}

export type DashboardSnapshotMetric = "os" | "cpu" | "memory" | "jvm" | "network" | "hardware" | "storage";
export type DashboardHistoryMetric = "cpu" | "memory" | "jvm" | "network";

export interface ServerDashboardSetting {
	snapshotRefreshSeconds: number;
	historyRefreshSeconds: number;
	snapshotMetrics: DashboardSnapshotMetric[];
	historyMetrics: DashboardHistoryMetric[];
}

export interface DashboardSetting {
	server: ServerDashboardSetting;
}

interface SettingState {
	connect: ConnectSetting;
	dashboard: DashboardSetting;
}

const defaultConnectSetting = (): ConnectSetting => ({
	protocol: "http",
	host: "",
	port: "",
	token: ""
});

const defaultServerDashboardSetting = (): ServerDashboardSetting => ({
	snapshotRefreshSeconds: 3,
	historyRefreshSeconds: 10,
	snapshotMetrics: ["os", "cpu", "memory", "jvm", "network", "hardware", "storage"],
	historyMetrics: ["cpu", "memory", "jvm", "network"]
});

const defaultDashboardSetting = (): DashboardSetting => ({
	server: defaultServerDashboardSetting()
});

const defaultSettingState = (): SettingState => ({
	connect: defaultConnectSetting(),
	dashboard: defaultDashboardSetting()
});

function normalizeConnectSetting(connect?: Partial<ConnectSetting>): ConnectSetting {
	const protocol = connect?.protocol === "https" ? "https" : "http";

	return {
		protocol,
		host: connect?.host?.trim() || "",
		port: connect?.port?.trim() || "",
		token: connect?.token?.trim() || ""
	};
}

function normalizeSnapshotMetrics(metrics?: DashboardSnapshotMetric[]): DashboardSnapshotMetric[] {
	const validMetrics: DashboardSnapshotMetric[] = ["os", "cpu", "memory", "jvm", "network", "hardware", "storage"];
	const metricList = Array.isArray(metrics) ? metrics : [];
	const normalizedMetrics = validMetrics.filter((metric) => metricList.includes(metric));
	return normalizedMetrics.length ? normalizedMetrics : defaultServerDashboardSetting().snapshotMetrics;
}

function normalizeHistoryMetrics(metrics?: DashboardHistoryMetric[]): DashboardHistoryMetric[] {
	const validMetrics: DashboardHistoryMetric[] = ["cpu", "memory", "jvm", "network"];
	const metricList = Array.isArray(metrics) ? metrics : [];
	const normalizedMetrics = validMetrics.filter((metric) => metricList.includes(metric));
	return normalizedMetrics.length ? normalizedMetrics : defaultServerDashboardSetting().historyMetrics;
}

function normalizeRefreshSeconds(value?: number, fallback = 3): number {
	if (typeof value !== "number" || Number.isNaN(value)) {
		return fallback;
	}

	return Math.min(Math.max(Math.floor(value), 1), 120);
}

function normalizeServerDashboardSetting(setting?: Partial<ServerDashboardSetting>): ServerDashboardSetting {
	const fallback = defaultServerDashboardSetting();
	return {
		snapshotRefreshSeconds: normalizeRefreshSeconds(setting?.snapshotRefreshSeconds, fallback.snapshotRefreshSeconds),
		historyRefreshSeconds: normalizeRefreshSeconds(setting?.historyRefreshSeconds, fallback.historyRefreshSeconds),
		snapshotMetrics: normalizeSnapshotMetrics(setting?.snapshotMetrics),
		historyMetrics: normalizeHistoryMetrics(setting?.historyMetrics)
	};
}

function normalizeDashboardSetting(setting?: Partial<DashboardSetting>): DashboardSetting {
	return {
		server: normalizeServerDashboardSetting(setting?.server)
	};
}

export const useSettingStore = defineStore("setting", () => {
	const state = ref<SettingState>(Storage.getDefault<SettingState>(SETTING_STORAGE_KEY, defaultSettingState()));
	state.value.connect = normalizeConnectSetting(state.value.connect);
	state.value.dashboard = normalizeDashboardSetting(state.value.dashboard);
	persist();

	const connect = computed(() => state.value.connect);
	const dashboard = computed(() => state.value.dashboard);
	const hasConnectConfig = computed(() => {
		const currentConnect = state.value.connect;
		return !!currentConnect.host && !!currentConnect.port && !!currentConnect.token;
	});

	function persist(): void {
		Storage.setObject(SETTING_STORAGE_KEY, state.value);
	}

	function setConnect(connectSetting: Partial<ConnectSetting>): void {
		state.value.connect = normalizeConnectSetting({
			...state.value.connect,
			...connectSetting
		});
		persist();
	}

	function resetConnect(): void {
		state.value.connect = defaultConnectSetting();
		persist();
	}

	function setServerDashboard(serverSetting: Partial<ServerDashboardSetting>): void {
		state.value.dashboard.server = normalizeServerDashboardSetting({
			...state.value.dashboard.server,
			...serverSetting
		});
		persist();
	}

	function resolveBaseURL(): string {
		const settingStore = useSettingStore();
		const connect = settingStore.connect;
		const envBaseURL = typeof import.meta.env.VITE_API === "string" ? import.meta.env.VITE_API.trim() : "";

		if (connect.host && connect.port) {
			return `${connect.protocol}://${connect.host}:${connect.port}`;
		}

		return envBaseURL.replace(/\/+$/, "");
	}

	return {
		connect,
		dashboard,
		hasConnectConfig,
		setConnect,
		resetConnect,
		setServerDashboard,
		resolveBaseURL
	};
});