import { requireAuthMode } from './auth.ts'
import {
	createObject,
	getObject,
	listObjects,
	searchObjects,
	updateObject,
	type CreateObjectInput,
	type GetObjectInput,
	type ListObjectsInput,
	type SearchObjectsInput,
	type UpdateObjectInput,
} from './objects.ts'
import type { StandardObjectType } from './models.ts'
import type { HubSpotAuthInput, HubSpotFilterGroup, JsonRecord } from './types.ts'
import {
	optionalBoolean,
	optionalString,
	optionalStringArray,
	requireRecord,
} from './types.ts'

export type StandardListInput = Omit<ListObjectsInput, 'objectType'>
export type StandardGetInput = Omit<GetObjectInput, 'objectType'>
export type StandardSearchInput = Omit<SearchObjectsInput, 'objectType'>
export type StandardCreateInput = Omit<CreateObjectInput, 'objectType'>
export type StandardUpdateInput = Omit<UpdateObjectInput, 'objectType'>

export function listStandard(objectType: StandardObjectType, input: StandardListInput = {}) {
	return listObjects({ ...input, objectType })
}

export function getStandard(objectType: StandardObjectType, input: StandardGetInput) {
	return getObject({ ...input, objectType })
}

export function searchStandard(objectType: StandardObjectType, input: StandardSearchInput = {}) {
	return searchObjects({ ...input, objectType })
}

export function createStandard(objectType: StandardObjectType, input: StandardCreateInput) {
	return createObject({ ...input, objectType })
}

export function updateStandard(objectType: StandardObjectType, input: StandardUpdateInput) {
	return updateObject({ ...input, objectType })
}

export function parseAuth(input: JsonRecord): HubSpotAuthInput {
	return {
		integrationName: optionalString(input.integrationName, 'integrationName'),
		integration: optionalString(input.integration, 'integration'),
		account: optionalString(input.account, 'account'),
		secretName: optionalString(input.secretName, 'secretName'),
		auth: requireAuthMode(input.auth),
	}
}

export function parseListInput(params: Record<string, unknown>, label: string): StandardListInput {
	const input = requireRecord(params, label)
	return {
		...parseAuth(input),
		limit: input.limit as number | undefined,
		after: optionalString(input.after, 'after'),
		properties: optionalStringArray(input.properties, 'properties'),
		archived: optionalBoolean(input.archived, 'archived'),
		associations: optionalStringArray(input.associations, 'associations'),
	}
}

export function parseGetInput(params: Record<string, unknown>, label: string): StandardGetInput {
	const input = requireRecord(params, label)
	return {
		...parseAuth(input),
		id: optionalString(input.id, 'id') ?? '',
		idProperty: optionalString(input.idProperty, 'idProperty'),
		properties: optionalStringArray(input.properties, 'properties'),
		archived: optionalBoolean(input.archived, 'archived'),
		associations: optionalStringArray(input.associations, 'associations'),
	}
}

export function parseSearchInput(
	params: Record<string, unknown>,
	label: string,
): StandardSearchInput {
	const input = requireRecord(params, label)
	return {
		...parseAuth(input),
		query: optionalString(input.query, 'query'),
		filterGroups: input.filterGroups as Array<HubSpotFilterGroup> | undefined,
		sorts: optionalStringArray(input.sorts, 'sorts'),
		properties: optionalStringArray(input.properties, 'properties'),
		limit: input.limit as number | undefined,
		after: optionalString(input.after, 'after'),
	}
}

export function parseCreateInput(
	params: Record<string, unknown>,
	label: string,
): StandardCreateInput {
	const input = requireRecord(params, label)
	return {
		...parseAuth(input),
		properties: requireRecord(input.properties, 'properties'),
		confirm: optionalBoolean(input.confirm, 'confirm'),
		dryRun: optionalBoolean(input.dryRun, 'dryRun'),
	}
}

export function parseUpdateInput(
	params: Record<string, unknown>,
	label: string,
): StandardUpdateInput {
	const input = requireRecord(params, label)
	return {
		...parseAuth(input),
		id: optionalString(input.id, 'id') ?? '',
		idProperty: optionalString(input.idProperty, 'idProperty'),
		properties: requireRecord(input.properties, 'properties'),
		confirm: optionalBoolean(input.confirm, 'confirm'),
		dryRun: optionalBoolean(input.dryRun, 'dryRun'),
	}
}