import Elysia, { t } from "elysia";
import type { User } from "generated/prisma";
import _ from "lodash";
import { prisma } from "../lib/prisma";

const UserRoute = new Elysia({
    prefix: "user",
    tags: ["user"],
})
    .get('/find', async (ctx) => {
        const { user } = ctx as any
        const permissions = await prisma.role.findFirst({
            where: { id: user?.roleId },
            select: { permissions: true }
        });

        return {
            user: user as User,
            permissions: permissions?.permissions || []
        }
    }, {
        detail: {
            summary: "find",
            description: "find user",
        }
    })
    .post("/upsert", async (ctx) => {
        const { name, phone } = ctx.body
        const upsert = await prisma.user.upsert({
            where: {
                phone
            },
            update: {
                name
            },
            create: {
                name,
                phone
            }
        })

        return {
            success: true,
            upsert
        }

    }, {
        body: t.Object({
            name: t.String({ minLength: 1, error: "name is required" }),
            phone: t.String({ minLength: 1, error: "phone is required" })
        }),
        detail: {
            summary: "upsert",
            description: "upsert user",
        }
    })
    .post("/update-password", async ({ body }) => {
        const { password, id } = body
        const update = await prisma.user.update({
            where: {
                id
            },
            data: {
                password
            }
        })

        return {
            success: true,
            message: "Password updated successfully",
        }
    }, {
        body: t.Object({
            password: t.String({ minLength: 1, error: "password is required" }),
            id: t.String({ minLength: 1, error: "id is required" })
        }),
        detail: {
            summary: "update password",
            description: "update password user",
        }
    })
    .post("/update", async ({ body }) => {
        const { name, phone, id, roleId } = body
        const update = await prisma.user.update({
            where: {
                id
            },
            data: {
                name,
                phone,
                roleId
            }
        })

        return {
            success: true,
            message: "User updated successfully",
        }
    }, {
        body: t.Object({
            name: t.String({ minLength: 1, error: "name is required" }),
            phone: t.String({ minLength: 1, error: "phone is required" }),
            id: t.String({ minLength: 1, error: "id is required" }),
            roleId: t.String({ minLength: 1, error: "roleId is required" })
        }),
        detail: {
            summary: "update",
            description: "update user",
        }
    })
    .post("/create", async ({ body }) => {
        const { name, phone, roleId, email, password } = body
        const create = await prisma.user.create({
            data: {
                name,
                phone,
                roleId,
                email,
                password
            }
        })

        return {
            success: true,
            message: "User created successfully",
        }
    }, {
        body: t.Object({
            name: t.String({ minLength: 1, error: "name is required" }),
            phone: t.String({ minLength: 1, error: "phone is required" }),
            roleId: t.String({ minLength: 1, error: "roleId is required" }),
            email: t.String({ minLength: 1, error: "email is required" }),
            password: t.String({ minLength: 1, error: "password is required" })
        }),
        detail: {
            summary: "create",
            description: "create user",
        }
    })
    .get("/list", async (ctx) => {
        const { user } = ctx as any

        const data = await prisma.user.findMany({
            where: {
                isActive: true,
                NOT: {
                    id: user.id
                }
            },
            select: {
                id: true,
                name: true,
                phone: true,
                email: true,
                roleId: true,
                Role: {
                    select: {
                        name: true
                    }
                }
            }
        })

        const dataFix = data.map((item: any) => ({
            ..._.omit(item, ["Role"]),
            nameRole: item.Role?.name,
            name: String(item.name),
            phone: String(item.phone),
            email: String(item.email),
            roleId: String(item.roleId),
        }))

        return dataFix
    }, {
        detail: {
            summary: "list",
            description: "list user",
        }
    })
    .get("/role", async () => {
        const data = await prisma.role.findMany({
            where: {
                isActive: true
            },
            orderBy: {
                name: "asc"
            }
        })
        return data
    }, {
        detail: {
            summary: "role",
            description: "role user",
        }
    })
    .post("/delete", async ({ body }) => {
        const { id } = body
        const deleteData = await prisma.user.update({
            where: {
                id
            },
            data: {
                isActive: false
            }
        })

        return {
            success: true,
            message: "User deleted successfully",
        }
    }, {
        body: t.Object({
            id: t.String({ minLength: 1, error: "id is required" })
        }),
        detail: {
            summary: "delete",
            description: "delete user",
        }
    })
    .post("role-create", async ({ body }) => {
        const { name, permissions } = body;
        const create = await prisma.role.create({
            data: {
                name,
                permissions: permissions
            }
        });

        return {
            success: true,
            message: "Role created successfully",
        };
    }, {
        body: t.Object({
            name: t.String({ minLength: 1, error: "name is required" }),
            permissions: t.Any(),
        }),
        detail: {
            summary: "create-role",
            description: "create role",
        }
    })
    .post("/role-update", async ({ body }) => {
        const { id, name, permissions } = body;
        const update = await prisma.role.update({
            where: {
                id
            },
            data: {
                name,
                permissions
            }
        });

        return {
            success: true,
            message: "User role updated successfully",
        };
    }, {
        body: t.Object({
            id: t.String({ minLength: 1, error: "id is required" }),
            name: t.String({ minLength: 1, error: "name is required" }),
            permissions: t.Any()
        }),
        detail: {
            summary: "update-role",
            description: "update role",
        }
    })
    .post("role-delete", async ({ body }) => {
        const { id } = body;
        await prisma.role.update({
            where: {
                id
            },
            data: {
                isActive: false
            }
        });

        return {
            success: true,
            message: "Role deleted successfully",
        };
    }, {
        body: t.Object({
            id: t.String({ minLength: 1, error: "id is required" })
        }),
        detail: {
            summary: "delete-role",
            description: "delete role",
        }
    })
    ;

export default UserRoute