import Hono from "@/lib/hono";
import { session_auth } from "@/middleware/authenticated";
import { delete_post_check, get_post_check, update_post_check } from '@/db/posts';
import { PostNotFoundError } from '@/lib/errors';
import { create_post } from '@/db/posts';
import { get_blog } from '@/db/blogs';
import { post_template } from "@/lib/post_template";
import eta from "@/lib/eta";
import { UUID_REGEX } from "@/lib/constants";
import type { Blog, Post } from "@/lib/types";
import { update_post_schema } from "@/lib/zod";
import { zValidator } from "@/lib/zod";
import { PostRemovedMessage, PostPublishedMessage, PostUnpublishedMessage } from "@/lib/messages";

const write = new Hono();

write.use("*", session_auth);

write.post(`/new/:blog{${UUID_REGEX.source}}`, async (c) => {
    let [user, blog_uuid, blog] = [c.get("user"), c.req.param("blog"), {} as Blog];
    try {
        blog = await get_blog(blog_uuid, user.id!);
        let post = post_template(blog.id!);
        post = await create_post(post);
        return c.redirect(`/write/${post.uuid}`);
    } catch (e) {
        return c.redirect("/dashboard?error=BlogNotFoundError");
    }
});

write.get(`/:uuid{${UUID_REGEX.source}}`, async (c) => {
    let [uuid, post, user] = [c.req.param('uuid'), {} as Post, c.get('user')];
    try {
        post = await get_post_check(user.id!, uuid);
        delete post.id;
        return eta(c, "editor", { post });
    } catch (e) {
        if (e instanceof PostNotFoundError) return c.notFound();
        console.error(e);
    }
}).post(zValidator("json", update_post_schema), async (c) => {
    const [user, uuid, body] = [
        c.get("user"),
        c.req.param("uuid"),
        c.req.valid("json"),
    ];

    if (!user || !uuid || !body) {
        return c.text("Bad Request.", 400);
    }

    try {
        const post = await update_post_check(user.id!, uuid, {
            ...body as Partial<Post>,
            published_at:
                body.publish === true
                    ? new Date()
                    : body.publish === false
                        ? null
                        : undefined,
        });

        const { blog_id, id, ...clean } = post

        return c.json({
            success: true,
            post: clean,
        });
    } catch (e: any) {
        return c.json({
            success: false,
            error: e,
        });
    }
});

write.post("/:uuid/delete", async (c) => {
    try {
        await delete_post_check(c.get("user").id!, c.req.param('uuid'));
        if (c.req.query('redirect')) {
            return c.redirect("/dashboard?message=PostRemovedMessage")
        }
        return c.json({
            success: true,
            message: PostRemovedMessage,
        });
    } catch (e) {
        let error = "Something went wrong.";
        if (e instanceof PostNotFoundError) error = "That post doesn't exist. It never did.";
        return c.json({
            success: false,
            error
        });
    }
});

write.on("POST", ["/:uuid/publish", "/:uuid/unpublish"], async (c) => {
    const action = c.req.path.split("/").pop();
    let published_at = null;
    let message = PostUnpublishedMessage.message;
    if (action == "publish") {
        published_at = new Date();
        message = PostPublishedMessage.message;
    }
    const uuid = c.req.param('uuid');
    const user = c.get('user');
    const redirect = (c.req.query('redirect') !== undefined);
    try {
        await update_post_check(user.id!, uuid, {
            published_at
        });

        if (redirect) {
            return c.redirect(`/dashboard?message=Post${action?.charAt(0).toUpperCase() + action!.slice(1)}edMessage`);
        }

        return c.json({
            success: true,
            message,
            published_at
        });
    } catch (e: any) {
        if (redirect) {
            return c.redirect(`/dashboard?error=${e.name}`);
        }
        return c.json({
            success: false,
            error: e,
        });
    }
})

export default write;