import { ItemHandler, ItemMessage } from "@olagg/protos";
import { GetItemResponse } from "@olagg/protos/dist/items/itemsPackage/GetItemResponse";
import { ListItemsResponse } from "@olagg/protos/dist/items/itemsPackage/ListItemsResponse";
import { container } from "tsyringe";
import Item from "../../domain/entities/item";
import { CreateItemAttr, DeleteItemAttr, UpdateItemAttr } from "../../domain/types/item.type";
import CreateItemService from "../../domain/services/createItem.service";
import GetItemService from "../../domain/services/getItem.service";
import ListItemsService from "../../domain/services/listItems.service";
import { FindItemAttr, ListItemAttr } from "../../domain/types/item.type";
import ItemType from "../../domain/entities/vo/itemType.vo";
import { CreateItemResponse } from "@olagg/protos/dist/items/itemsPackage/CreateItemResponse";
import UpdateItemService from "../../domain/services/updateItem.service";
import { UpdateItemResponse } from "@olagg/protos/dist/items/itemsPackage/UpdateItemResponse";
import DeleteItemService from "../../domain/services/deleteItem.service";
import { DeleteItemResponse } from "@olagg/protos/dist/items/itemsPackage/DeleteItemResponse";
import ListUserStockService from "../../domain/services/listUserStock.service";
import { AssignStockAttr, CreateStockAttr, GenerateStockAttr, ListUserStockAttr } from "../../domain/types/stock.type";
import CreateStockService from "../../domain/services/createStock";
import { CreateStockResponse } from "@olagg/protos/dist/items/itemsPackage/CreateStockResponse";
import AssignStockToUserService from "../../domain/services/assignStockToUser";
import { UpdateStockResponse } from "@olagg/protos/dist/items/itemsPackage/UpdateStockResponse";
import { GetUserStockResponse } from "@olagg/protos/dist/items/itemsPackage/GetUserStockResponse";
import { AddStockResponse } from "@olagg/protos/dist/items/itemsPackage/AddStockResponse";
import ListStockService from "../../domain/services/listStock.service";

export const definitions = {
    GetItem: (req, res) => {
        const service = container.resolve<GetItemService>("Items:GetItemService");
        const payload: FindItemAttr = {
            id: req.request.id!
        };
        service.run(payload).then(result => {
            if (result.isSuccess) {
                const data = result.data();
                const response: GetItemResponse = {
                    item: buildItemResponse(data)
                };
                res(null, response);
            } else {
                const error = buildError(result.error);
                res(error, null);
            }
        });
    },
    ListItems: (req, res) => {
        const service = container.resolve<ListItemsService>("Items:ListItemsService");
        const payload: ListItemAttr = {
            page: req.request.page,
            itemType: req.request.type && [req.request.type] as ItemType[],
            userId: req.request.userId,
            visible: req.request.visible
        };

        service.run(payload).then(result => {
            if (result.isSuccess) {
                const data = result.data();
                const response: ListItemsResponse = {
                    count: data.count,
                    items: data.items.map(item => buildItemResponse(item))
                };
                res(null, response);
            } else {
                const error = buildError(result.error);
                res(error, null);
            }
        });
    },
    CreateItem: (req, res) => {
        const service = container.resolve<CreateItemService>("Items:CreateItemService");
        const payload: CreateItemAttr = {
            name: req.request.name!,
            description: req.request.description!,
            type: req.request.type! as ItemType,
            price: req.request.price!,
            image: req.request.image!,
            link: req.request.link!,
            dueDate: req.request.dueDate ? new Date(req.request.dueDate) : undefined,
            visible: req.request.visible || true,
            onClickRedirect: req.request.onClickRedirect
        };
        service.run(payload).then(result => {
            if (result.isSuccess) {
                const data = result.data();
                const response: CreateItemResponse = {
                    item: buildItemResponse(data)
                };
                res(null, response);
            } else {
                const error = buildError(result.error);
                res(error, null);
            }
        });
    },
    UpdateItem: (req, res) => {
        const service = container.resolve<UpdateItemService>("Items:UpdateItemService");
        const payload: UpdateItemAttr = {
            id: req.request.id!,
            data: {
                name: req.request.name!,
                description: req.request.description!,
                type: req.request.type! as ItemType,
                dueDate: req.request.dueDate ? new Date(req.request.dueDate) : undefined,
                price: req.request.price!,
                link: req.request.link!,
                image: req.request.image!,
                visible: req.request.visible,
                onClickRedirect: req.request.onClickRedirect
            }
        };
        service.run(payload).then(result => {
            if (result.isSuccess) {
                const data = result.data();
                const response: UpdateItemResponse = {
                    item: buildItemResponse(data)
                };
                res(null, response);
            } else {
                const error = buildError(result.error);
                res(error, null);
            }
        });
    },
    DeleteItem: (req, res) => {
        const service = container.resolve<DeleteItemService>("Items:DeleteItemService");
        const payload: DeleteItemAttr = {
            id: req.request.id!
        };
        service.run(payload).then(result => {
            if (result.isSuccess) {
                const response: DeleteItemResponse = {
                    deleted: true
                };
                res(null, response);
            } else {
                const error = buildError(result.error);
                res(error, null);
            }
        });
    },
    GetUserStock: (req, res) => {
        const service = container.resolve<ListUserStockService>("Stock:ListUserStockService");
        const payload: ListUserStockAttr = {
            userId: req.request.userId!,
            page: req.request.page,
        };
        service.run(payload).then(result => {
            if (result.isSuccess) {
                const data = result.data();
                const response: GetUserStockResponse = {
                    count: data.count,
                    stock: data.stock.map(s => {
                        return {
                            item: buildItemResponse(s.item),
                            code: s.code,
                            assignedToId: s.assignedToId
                        };
                    })
                };
                res(null, response);
            } else {
                const error = buildError(result.error);
                res(error, null);
            }
        });
    },
    CreateStock: (req, res) => {
        const service = container.resolve<CreateStockService>("Stock:CreateStockService");
        const stock: { code: string }[] = [];
        req.request.stock?.map(s => stock.push({ code: s.code! }));
        const payload: CreateStockAttr = {
            itemId: req.request.itemId!,
            stock
        };
        service.run(payload).then(result => {
            if (result.isSuccess) {
                const data = result.data();
                const response: CreateStockResponse = {
                    item: buildItemResponse(data[0].item),
                };
                res(null, response);
            } else {
                const error = buildError(result.error);
                res(error, null);
            }
        });
    },
    UpdateStock: (req, res) => {
        const service = container.resolve<AssignStockToUserService>("Stock:AssignStockToUserService");
        const payload: AssignStockAttr = {
            itemId: req.request.itemId!,
            userId: req.request.userId!,
        };
        service.run(payload).then(result => {
            if (result.isSuccess) {
                const stock = result.data();
                const response: UpdateStockResponse = {
                    stock: {
                        item: buildItemResponse(stock.item),
                        code: stock.code,
                        assignedToId: stock.assignedToId
                    }
                };
                res(null, response);
            } else {
                const error = buildError(result.error);
                res(error, null);
            }
        });
    },
    AssignFromCipher: (req, res) => {
        const service = container.resolve<AssignStockToUserService>("Stock:AssignStockToUserService");

        const { itemId, userId, cipher } = req.request;
        service.fromCode(itemId!, userId!, cipher!).then(result => {
            if (result.isSuccess) {
                const stock = result.data();
                const response: UpdateStockResponse = {
                    stock: {
                        item: buildItemResponse(stock.item),
                        code: stock.code,
                        assignedToId: stock.assignedToId
                    }
                };
                res(null, response);
            } else {
                const error = buildError(result.error);
                res(error, null);
            }
        });

    },
    AddStock: (req, res) => {
        const service = container.resolve<CreateStockService>("Stock:CreateStockService");
        const payload: GenerateStockAttr = {
            itemId: req.request.itemId!,
            quantity: req.request.quantity!,
        };
        service.generate(payload).then(result => {
            if (result.isSuccess) {
                const stock = result.data();
                const response: AddStockResponse = {
                    stock: stock.map(s => ({
                        item: buildItemResponse(s.item),
                        code: s.code,
                        cipher: s.encodedCode,
                    }))
                };
                res(null, response);
            } else {
                const error = buildError(result.error);
                res(error, null);
            }
        });
    },
    ListStock: (req, res) => {
        const service = container.resolve<ListStockService>("Stock:ListStockService");
        const { itemId, page, withCoupon } = req.request;
        service.execute(itemId!, page, withCoupon).then(result => {
            if (result.isSuccess) {
                const data = result.data();
                const response: GetUserStockResponse = {
                    count: data.count,
                    stock: data.stock.map(s => {
                        return {
                            item: buildItemResponse(s.item),
                            code: s.code,
                            cipher: s.encodedCode,
                            assignedToId: s.assignedToId
                        };
                    })
                };
                res(null, response);
            } else {
                const error = buildError(result.error);
                res(error, null);
            }
        });
    }
} as ItemHandler;

const buildItemResponse = (item: Item): ItemMessage => {
    const response: ItemMessage = {
        id: item.id,
        name: item.name,
        description: item.description,
        type: item.type,
        image: item.image,
        link: item.link,
        dueDate: item.dueDate?.toISOString(),
        status: item.status,
        availableStock: item.availableStock,
        couponsAvailable: item.couponsAvailable,
        couponsTaken: item.couponsTaken,
        price: item.price,
        assigned: item.assigned,
        visible: item.visible,
        onClickRedirect: item.onClickRedirect,
        totalCodes: item.totalCodes
    };

    return response;
};

const buildError = (error: unknown) => {
    const _error = {
        name: "Error",
        message: error as string
    };

    return _error;
};