import type {
	ProductDiscount,
	ProductDiscountChangeIsActiveAction,
	ProductDiscountChangeNameAction,
	ProductDiscountChangePredicateAction,
	ProductDiscountChangeSortOrderAction,
	ProductDiscountChangeValueAction,
	ProductDiscountDraft,
	ProductDiscountSetDescriptionAction,
	ProductDiscountSetKeyAction,
	ProductDiscountSetValidFromAction,
	ProductDiscountSetValidFromAndUntilAction,
	ProductDiscountSetValidUntilAction,
	ProductDiscountUpdateAction,
	ProductDiscountValue,
	ProductDiscountValueAbsolute,
	ProductDiscountValueDraft,
	ProductDiscountValueExternal,
	ProductDiscountValueRelative,
} from "@commercetools/platform-sdk";
import type { Config } from "#src/config.ts";
import { ProductDiscountDraftSchema } from "#src/schemas/generated/product-discount.ts";
import { getBaseResourceProperties } from "../helpers.ts";
import type { Writable } from "../types.ts";
import type { RepositoryContext, UpdateHandlerInterface } from "./abstract.ts";
import {
	AbstractResourceRepository,
	AbstractUpdateHandler,
} from "./abstract.ts";
import { createTypedMoney } from "./helpers.ts";

export class ProductDiscountRepository extends AbstractResourceRepository<"product-discount"> {
	constructor(config: Config) {
		super("product-discount", config);
		this.actions = new ProductDiscountUpdateHandler(this._storage);
		this.draftSchema = ProductDiscountDraftSchema;
	}

	async create(
		context: RepositoryContext,
		draft: ProductDiscountDraft,
	): Promise<ProductDiscount> {
		const resource: ProductDiscount = {
			...getBaseResourceProperties(context.clientId),
			key: draft.key,
			name: draft.name,
			description: draft.description,
			value: transformValueDraft(draft.value),
			predicate: draft.predicate,
			sortOrder: draft.sortOrder,
			isActive: draft.isActive || false,
			validFrom: draft.validFrom,
			validUntil: draft.validUntil,
			references: [],
		};
		return await this.saveNew(context, resource);
	}
}

const transformValueDraft = (
	value: ProductDiscountValueDraft,
): ProductDiscountValue => {
	switch (value.type) {
		case "absolute": {
			return {
				type: "absolute",
				money: value.money.map(createTypedMoney),
			} as ProductDiscountValueAbsolute;
		}
		case "external": {
			return {
				type: "external",
			} as ProductDiscountValueExternal;
		}
		case "relative": {
			return {
				...value,
			} as ProductDiscountValueRelative;
		}
	}
};

export class ProductDiscountUpdateHandler
	extends AbstractUpdateHandler
	implements
		UpdateHandlerInterface<ProductDiscount, ProductDiscountUpdateAction>
{
	changeIsActive(
		context: RepositoryContext,
		resource: Writable<ProductDiscount>,
		{ isActive }: ProductDiscountChangeIsActiveAction,
	) {
		resource.isActive = isActive;
	}

	changeName(
		context: RepositoryContext,
		resource: Writable<ProductDiscount>,
		{ name }: ProductDiscountChangeNameAction,
	) {
		resource.name = name;
	}

	changePredicate(
		context: RepositoryContext,
		resource: Writable<ProductDiscount>,
		{ predicate }: ProductDiscountChangePredicateAction,
	) {
		resource.predicate = predicate;
	}

	changeSortOrder(
		context: RepositoryContext,
		resource: Writable<ProductDiscount>,
		{ sortOrder }: ProductDiscountChangeSortOrderAction,
	) {
		resource.sortOrder = sortOrder;
	}

	changeValue(
		context: RepositoryContext,
		resource: Writable<ProductDiscount>,
		{ value }: ProductDiscountChangeValueAction,
	) {
		resource.value = transformValueDraft(value);
	}

	setDescription(
		context: RepositoryContext,
		resource: Writable<ProductDiscount>,
		{ description }: ProductDiscountSetDescriptionAction,
	) {
		if (description && Object.keys(description).length > 0) {
			resource.description = description;
		} else {
			resource.description = undefined;
		}
	}

	setKey(
		context: RepositoryContext,
		resource: Writable<ProductDiscount>,
		{ key }: ProductDiscountSetKeyAction,
	) {
		resource.key = key;
	}

	setValidFrom(
		context: RepositoryContext,
		resource: Writable<ProductDiscount>,
		{ validFrom }: ProductDiscountSetValidFromAction,
	) {
		resource.validFrom = validFrom;
	}

	setValidFromAndUntil(
		context: RepositoryContext,
		resource: Writable<ProductDiscount>,
		{ validFrom, validUntil }: ProductDiscountSetValidFromAndUntilAction,
	) {
		resource.validFrom = validFrom;
		resource.validUntil = validUntil;
	}

	setValidUntil(
		context: RepositoryContext,
		resource: Writable<ProductDiscount>,
		{ validUntil }: ProductDiscountSetValidUntilAction,
	) {
		resource.validUntil = validUntil;
	}
}