import { Type, type Static } from "typebox";

export const GOAL_SCHEMA_VERSION = 1 as const;
export const GOAL_STATE_ENTRY = "pi-goal-state-v1";
export const GOAL_RECEIPT_ENTRY = "pi-goal-receipt-v1";
export const GOAL_PROPOSAL_REVISION_ENTRY = "pi-goal-proposal-revision-v1";
export const GOAL_STATE_EVENT = "pi-goal:state";
export const GOAL_STATE_REQUEST_EVENT = "pi-goal:request-state";
export const GOAL_PROPOSAL_EVENT = "pi-goal:proposal";
export const GOAL_AUDIT_EVENT = "pi-goal:audit";
export const GOAL_AUDIT_EVENT_VERSION = 1 as const;
export const GOAL_CONTINUATION_MESSAGE = "pi-goal-continuation-v1";
export const GOAL_ID_MAX_LENGTH = 256;
export const GOAL_OBJECTIVE_MAX_LENGTH = 128 * 1024;
export const GOAL_TIMESTAMP_MAX_LENGTH = 64;
export const GOAL_PAUSE_REASON_MAX_LENGTH = 2_048;
export const GOAL_PAUSE_SUGGESTED_ACTION_MAX_LENGTH = 2_048;
export const GOAL_AUDIT_REJECTION_REPORT_MAX_LENGTH = 12_000;
export const GOAL_COMPLETION_SUMMARY_MAX_LENGTH = 4_000;
export const GOAL_COMPLETION_AUDITOR_REPORT_MAX_LENGTH = 12_000;
export const GOAL_PROPOSAL_COMMENT_MAX_LENGTH = 4_000;

export const GoalUsageSchema = Type.Object({
	tokensUsed: Type.Number({ minimum: 0 }),
	activeSeconds: Type.Number({ minimum: 0 }),
}, { additionalProperties: false });

export const GoalPauseSchema = Type.Object({
	reason: Type.String({ minLength: 1, maxLength: GOAL_PAUSE_REASON_MAX_LENGTH }),
	suggestedAction: Type.Optional(Type.String({ minLength: 1, maxLength: GOAL_PAUSE_SUGGESTED_ACTION_MAX_LENGTH })),
}, { additionalProperties: false });

export const GoalAuditRejectionSchema = Type.Object({
	rejectedAt: Type.String({ minLength: 1, maxLength: GOAL_TIMESTAMP_MAX_LENGTH }),
	report: Type.String({ minLength: 1, maxLength: GOAL_AUDIT_REJECTION_REPORT_MAX_LENGTH }),
}, { additionalProperties: false });

export const GoalCompletionSchema = Type.Object({
	approvedAt: Type.String({ minLength: 1, maxLength: GOAL_TIMESTAMP_MAX_LENGTH }),
	summary: Type.String({ minLength: 1, maxLength: GOAL_COMPLETION_SUMMARY_MAX_LENGTH }),
	auditorReport: Type.String({ minLength: 1, maxLength: GOAL_COMPLETION_AUDITOR_REPORT_MAX_LENGTH }),
}, { additionalProperties: false });

const GoalCommonProperties = {
	id: Type.String({ minLength: 1, maxLength: GOAL_ID_MAX_LENGTH }),
	objective: Type.String({ minLength: 1, maxLength: GOAL_OBJECTIVE_MAX_LENGTH }),
	usage: GoalUsageSchema,
	createdAt: Type.String({ minLength: 1, maxLength: GOAL_TIMESTAMP_MAX_LENGTH }),
	updatedAt: Type.String({ minLength: 1, maxLength: GOAL_TIMESTAMP_MAX_LENGTH }),
	pause: Type.Optional(GoalPauseSchema),
	lastAuditRejection: Type.Optional(GoalAuditRejectionSchema),
	completion: Type.Optional(GoalCompletionSchema),
};

export const GoalSchema = Type.Union([
	Type.Object({ ...GoalCommonProperties, status: Type.Literal("active"), autoContinue: Type.Literal(true) }, { additionalProperties: false }),
	Type.Object({ ...GoalCommonProperties, status: Type.Literal("paused"), autoContinue: Type.Literal(false) }, { additionalProperties: false }),
	Type.Object({ ...GoalCommonProperties, status: Type.Literal("complete"), autoContinue: Type.Literal(false) }, { additionalProperties: false }),
]);

export const GoalStateSchema = Type.Object({
	schemaVersion: Type.Literal(GOAL_SCHEMA_VERSION),
	revision: Type.Integer({ minimum: 0 }),
	goal: Type.Union([GoalSchema, Type.Null()]),
}, { additionalProperties: false });

export const GoalProposalSchema = Type.Object({
	schemaVersion: Type.Literal(GOAL_SCHEMA_VERSION),
	revision: Type.Integer({ minimum: 0 }),
	proposal: Type.Union([
		Type.Object({
			kind: Type.Union([Type.Literal("create"), Type.Literal("tweak")]),
			objective: Type.String({ minLength: 1, maxLength: GOAL_OBJECTIVE_MAX_LENGTH }),
			currentObjective: Type.Optional(Type.String({ minLength: 1, maxLength: GOAL_OBJECTIVE_MAX_LENGTH })),
		}, { additionalProperties: false }),
		Type.Null(),
	]),
}, { additionalProperties: false });

export type GoalUsage = Static<typeof GoalUsageSchema>;
export type GoalPause = Static<typeof GoalPauseSchema>;
export type GoalAuditRejection = Static<typeof GoalAuditRejectionSchema>;
export type GoalCompletion = Static<typeof GoalCompletionSchema>;
export const GoalAuditEventSchema = Type.Object({
	version: Type.Literal(GOAL_AUDIT_EVENT_VERSION),
	goalId: Type.String({ minLength: 1, maxLength: GOAL_ID_MAX_LENGTH }),
	active: Type.Boolean(),
	emittedAt: Type.String({ minLength: 1, maxLength: GOAL_TIMESTAMP_MAX_LENGTH }),
}, { additionalProperties: false });

export type Goal = Static<typeof GoalSchema>;
export type GoalState = Static<typeof GoalStateSchema>;
export type GoalProposal = Static<typeof GoalProposalSchema>;
export type GoalAuditEvent = Static<typeof GoalAuditEventSchema>;

function record(value: unknown): Record<string, unknown> | null {
	return value !== null && typeof value === "object" && !Array.isArray(value)
		? value as Record<string, unknown>
		: null;
}

function nonEmptyString(value: unknown, maxLength = Number.POSITIVE_INFINITY): value is string {
	return typeof value === "string" && value.trim().length > 0 && value.length <= maxLength;
}

function hasOnlyKeys(raw: Record<string, unknown>, allowed: readonly string[]): boolean {
	const keys = new Set(allowed);
	return Object.keys(raw).every((key) => keys.has(key));
}

function validUsage(value: unknown): value is GoalUsage {
	const raw = record(value);
	return !!raw && hasOnlyKeys(raw, ["tokensUsed", "activeSeconds"])
		&& typeof raw.tokensUsed === "number" && Number.isFinite(raw.tokensUsed) && raw.tokensUsed >= 0
		&& typeof raw.activeSeconds === "number" && Number.isFinite(raw.activeSeconds) && raw.activeSeconds >= 0;
}

export function isGoal(value: unknown): value is Goal {
	const raw = record(value);
	if (!raw || !hasOnlyKeys(raw, ["id", "objective", "status", "autoContinue", "usage", "createdAt", "updatedAt", "pause", "lastAuditRejection", "completion"])) return false;
	if (!nonEmptyString(raw.id, GOAL_ID_MAX_LENGTH) || !nonEmptyString(raw.objective, GOAL_OBJECTIVE_MAX_LENGTH)) return false;
	if (raw.status !== "active" && raw.status !== "paused" && raw.status !== "complete") return false;
	if (raw.autoContinue !== (raw.status === "active") || !validUsage(raw.usage)) return false;
	if (!nonEmptyString(raw.createdAt, GOAL_TIMESTAMP_MAX_LENGTH) || !nonEmptyString(raw.updatedAt, GOAL_TIMESTAMP_MAX_LENGTH)) return false;
	const pause = raw.pause === undefined ? null : record(raw.pause);
	if (raw.pause !== undefined && (!pause || !hasOnlyKeys(pause, ["reason", "suggestedAction"]) || !nonEmptyString(pause.reason, GOAL_PAUSE_REASON_MAX_LENGTH) || (pause.suggestedAction !== undefined && !nonEmptyString(pause.suggestedAction, GOAL_PAUSE_SUGGESTED_ACTION_MAX_LENGTH)))) return false;
	const rejection = raw.lastAuditRejection === undefined ? null : record(raw.lastAuditRejection);
	if (raw.lastAuditRejection !== undefined && (!rejection || !hasOnlyKeys(rejection, ["rejectedAt", "report"]) || !nonEmptyString(rejection.rejectedAt, GOAL_TIMESTAMP_MAX_LENGTH) || !nonEmptyString(rejection.report, GOAL_AUDIT_REJECTION_REPORT_MAX_LENGTH))) return false;
	const completion = raw.completion === undefined ? null : record(raw.completion);
	if (raw.completion !== undefined && (!completion || !hasOnlyKeys(completion, ["approvedAt", "summary", "auditorReport"]) || !nonEmptyString(completion.approvedAt, GOAL_TIMESTAMP_MAX_LENGTH) || !nonEmptyString(completion.summary, GOAL_COMPLETION_SUMMARY_MAX_LENGTH) || !nonEmptyString(completion.auditorReport, GOAL_COMPLETION_AUDITOR_REPORT_MAX_LENGTH))) return false;
	return true;
}

export function isGoalState(value: unknown): value is GoalState {
	const raw = record(value);
	return !!raw && hasOnlyKeys(raw, ["schemaVersion", "revision", "goal"])
		&& raw.schemaVersion === GOAL_SCHEMA_VERSION
		&& typeof raw.revision === "number" && Number.isSafeInteger(raw.revision) && raw.revision >= 0
		&& (raw.goal === null || isGoal(raw.goal));
}

export function parseGoalState(value: unknown): GoalState | null {
	return isGoalState(value) ? structuredClone(value) : null;
}

export function isGoalProposal(value: unknown): value is GoalProposal {
	const raw = record(value);
	if (!raw || !hasOnlyKeys(raw, ["schemaVersion", "revision", "proposal"])) return false;
	if (raw.schemaVersion !== GOAL_SCHEMA_VERSION || typeof raw.revision !== "number" || !Number.isSafeInteger(raw.revision) || raw.revision < 0) return false;
	if (raw.proposal === null) return true;
	const proposal = record(raw.proposal);
	return !!proposal && hasOnlyKeys(proposal, ["kind", "objective", "currentObjective"])
		&& (proposal.kind === "create" || proposal.kind === "tweak")
		&& nonEmptyString(proposal.objective, GOAL_OBJECTIVE_MAX_LENGTH)
		&& (proposal.currentObjective === undefined || nonEmptyString(proposal.currentObjective, GOAL_OBJECTIVE_MAX_LENGTH));
}

export function parseGoalProposal(value: unknown): GoalProposal | null {
	return isGoalProposal(value) ? structuredClone(value) : null;
}

export function isGoalAuditEvent(value: unknown): value is GoalAuditEvent {
	const raw = record(value);
	return !!raw && hasOnlyKeys(raw, ["version", "goalId", "active", "emittedAt"])
		&& raw.version === GOAL_AUDIT_EVENT_VERSION
		&& nonEmptyString(raw.goalId, GOAL_ID_MAX_LENGTH)
		&& typeof raw.active === "boolean"
		&& nonEmptyString(raw.emittedAt, GOAL_TIMESTAMP_MAX_LENGTH);
}

export function parseGoalAuditEvent(value: unknown): GoalAuditEvent | null {
	return isGoalAuditEvent(value) ? structuredClone(value) : null;
}