import mongoose from "mongoose";
import { MonitorTypes } from "@/types/monitor.js";

const cpuSchema = new mongoose.Schema(
	{
		physical_core: { type: Number, default: 0 },
		logical_core: { type: Number, default: 0 },
		frequency: { type: Number, default: 0 },
		temperature: { type: [Number], default: [] },
		free_percent: { type: Number, default: 0 },
		usage_percent: { type: Number, default: 0 },
	},
	{ _id: false }
);

const memorySchema = new mongoose.Schema(
	{
		total_bytes: { type: Number, default: 0 },
		available_bytes: { type: Number, default: 0 },
		used_bytes: { type: Number, default: 0 },
		usage_percent: { type: Number, default: 0 },
	},
	{ _id: false }
);

const diskSchema = new mongoose.Schema(
	{
		device: { type: String, default: "" },
		mountpoint: { type: String, default: "" },
		read_speed_bytes: { type: Number, default: 0 },
		write_speed_bytes: { type: Number, default: 0 },
		total_bytes: { type: Number, default: 0 },
		free_bytes: { type: Number, default: 0 },
		usage_percent: { type: Number, default: 0 },
	},
	{ _id: false }
);

const hostSchema = new mongoose.Schema(
	{
		os: { type: String, default: "" },
		platform: { type: String, default: "" },
		kernel_version: { type: String, default: "" },
	},
	{ _id: false }
);

const errorSchema = new mongoose.Schema(
	{
		metric: { type: [String], default: [] },
		err: { type: String, default: "" },
	},
	{ _id: false }
);

const captureSchema = new mongoose.Schema(
	{
		version: { type: String, default: "" },
		mode: { type: String, default: "" },
	},
	{ _id: false }
);

const networkInterfaceSchema = new mongoose.Schema(
	{
		name: { type: String },
		bytes_sent: { type: Number, default: 0 },
		bytes_recv: { type: Number, default: 0 },
		packets_sent: { type: Number, default: 0 },
		packets_recv: { type: Number, default: 0 },
		err_in: { type: Number, default: 0 },
		err_out: { type: Number, default: 0 },
		drop_in: { type: Number, default: 0 },
		drop_out: { type: Number, default: 0 },
		fifo_in: { type: Number, default: 0 },
		fifo_out: { type: Number, default: 0 },
	},
	{ _id: false }
);

const metadataSchema = new mongoose.Schema(
	{
		monitorId: {
			type: mongoose.Schema.Types.ObjectId,
			ref: "Monitor",
			immutable: true,
			index: true,
		},
		teamId: {
			type: mongoose.Schema.Types.ObjectId,
			ref: "Team",
			immutable: true,
			index: true,
		},
		type: {
			type: String,
			enum: MonitorTypes,
			required: true,
			index: true,
		},
	},
	{ _id: false }
);

const CheckSchema = new mongoose.Schema(
	{
		metadata: {
			type: metadataSchema,
			required: true,
		},
		status: {
			type: Boolean,
			index: true,
		},

		responseTime: {
			type: Number,
		},

		timings: {
			type: Object,
			default: {},
		},

		statusCode: {
			type: Number,
			index: true,
		},

		message: {
			type: String,
		},

		expiry: {
			type: Date,
			default: Date.now,
		},

		ack: {
			type: Boolean,
			default: false,
		},

		ackAt: {
			type: Date,
		},

		// Hardware fields
		cpu: {
			type: cpuSchema,
			default: () => ({}),
		},
		memory: {
			type: memorySchema,
			default: () => ({}),
		},
		disk: {
			type: [diskSchema],
			default: () => [],
		},
		host: {
			type: hostSchema,
			default: () => ({}),
		},

		errors: {
			type: [errorSchema],
			default: () => [],
		},

		capture: {
			type: captureSchema,
			default: () => ({}),
		},

		net: {
			type: [networkInterfaceSchema],
			default: () => [],
		},

		// PageSpeed fields
		accessibility: {
			type: Number,
		},
		bestPractices: {
			type: Number,
		},
		seo: {
			type: Number,
		},
		performance: {
			type: Number,
		},
		audits: {
			type: Object,
		},
	},
	{
		timestamps: true,
		strict: false,
		timeseries: {
			timeField: "createdAt",
			metaField: "metadata",
			granularity: "seconds",
		},
	}
);

CheckSchema.index({ updatedAt: 1 });
CheckSchema.index({ "metadata.monitorId": 1, updatedAt: 1 });
CheckSchema.index({ "metadata.monitorId": 1, updatedAt: -1 });
CheckSchema.index({ "metadata.teamId": 1, updatedAt: -1 });

export default mongoose.model("Check", CheckSchema);