import { eq } from "drizzle-orm";
import { db } from "../../db";
import { projects, uploads } from "../../db/schema";
import { createEmptyProject } from "../../helper/projects/createProject";
import { createBucket } from "../../helper/upload/createBucket";
import { removeBucket } from "../../helper/upload/removeBucket";

export const getAllProjects = async (userId: string, token: string) => {
  try {
    // Fetch all projects for the given user
    const allProjects = await db
      .select({
        id: projects.id,
        name: projects.name,
        description: projects.description,
        preview_url: projects.preview_url,
        object: projects.object,
      })
      .from(projects)
      .where(eq(projects.userId, userId));

    // Identify projects where 'object' is empty or 'object.objects' is empty
    const projectsToDelete = allProjects.filter(
      (proj) =>
        (proj.object &&
          typeof proj.object === "object" &&
          Object.keys(proj.object).length === 0) ||
        (proj.object?.objects &&
          Array.isArray(proj.object.objects) &&
          proj.object.objects.length === 0)
    );

    // Delete projects with empty 'object' or empty 'object.objects'
    await Promise.all(
      projectsToDelete.map(async (proj) => {
        // Step 1: Delete associated uploads first
        await db.delete(uploads).where(eq(uploads.projectId, proj.id));

        // Step 2: Delete the project itself
        await db.delete(projects).where(eq(projects.id, proj.id));

        // Step 3: Delete the associated bucket
        await removeBucket(proj.id);
      })
    );

    // Get remaining projects
    const remainingProjects = allProjects.filter(
      (proj) =>
        !(
          (proj.object &&
            typeof proj.object === "object" &&
            Object.keys(proj.object).length === 0) ||
          (proj.object?.objects &&
            Array.isArray(proj.object.objects) &&
            proj.object.objects.length === 0)
        )
    );

    if (remainingProjects.length === 0) {
      return { status: 404, message: "No projects found", token };
    }

    return {
      status: 200,
      message: "Projects fetched successfully",
      data: remainingProjects,
      token,
    };
  } catch (error: any) {
    console.log(error.message);
    return {
      status: 500,
      message: "An error occurred while fetching projects",
      token,
    };
  }
};

export const getEachProjects = async (id: string, token: string) => {
  try {
    const project = await db
      .select({
        id: projects.id,
        name: projects.name,
        description: projects.description,
        preview_url: projects.preview_url,
        object: projects.object,
      })
      .from(projects)
      .where(eq(projects.id, id))
      .limit(1);
    if (project.length === 0) {
      return { status: 404, message: "Project not found", token };
    }
    return {
      status: 200,
      message: "Project fetched successfully",
      data: project[0],
      token,
    };
  } catch (error: any) {
    console.log(error.message);
    return {
      status: 500,
      message: "An error occurred while fetching projects",
      token,
    };
  }
};

export const createProject = async (userId: string, token: string) => {
  try {
    const { id } = await createEmptyProject(userId);
    const bucket = await createBucket(id);
    return {
      status: 200,
      message: "New project created successfully",
      data: { id, bucketName: bucket },
      token,
    };
  } catch (error: any) {
    console.log(error.message);
    return {
      status: 500,
      message: "An error occurred while creating projects",
      token,
    };
  }
};

export const updateProject = async (
  id: string,
  body: any,
  token: string,
  user_id: string
) => {
  try {
    // 1. Validate if project exists
    const existingProject = await db
      .select()
      .from(projects)
      .where(eq(projects.id, id));
    if (existingProject.length === 0) {
      return { status: 404, message: "Project not found", token };
    }

    const { object, name, description, preview_url } = body;
    // The preview_url will come from client-side as well, where before updating the project a project capture will be taken and uploaded to the bucket. than the url will be sent to the server.And rest of them are normal process

    const updatedProject = await db
      .update(projects)
      .set({
        object,
        name,
        description,
        preview_url,
        userId: user_id,
      })
      .where(eq(projects.id, id))
      .returning({
        id: projects.id,
        object: projects.object,
        name: projects.name,
        description: projects.description,
        preview_url: projects.preview_url,
      });

    if (updatedProject.length === 0) {
      return { status: 500, message: "Failed to update the project", token };
    }
    return {
      status: 200,
      message: "Project updated successfully",
      data: updatedProject[0],
      token,
    };
  } catch (error: any) {
    console.log("Error updating project:", error.message || error.toString());
    return {
      status: 500,
      message: "An error occurred while updating the project",
      token,
    };
  }
};

export const deleteProject = async (id: string, token: string) => {
  try {
    const deletedUploads = await db
      .delete(uploads)
      .where(eq(uploads.projectId, id))
      .returning({ id: uploads.id });

    if (deletedUploads.length >= 0) {
      // Step 4: Delete the project
      const deletedProject = await db
        .delete(projects)
        .where(eq(projects.id, id))
        .returning({ id: projects.id });

      if (deletedProject.length === 0) {
        return { status: 404, message: "Project not found", token };
      }

      // Step 5: Delete the associated bucket
      const bucketDeletionResult = await removeBucket(id);

      if (bucketDeletionResult.status !== 200) {
        return {
          status: bucketDeletionResult.status,
          message: `Error deleting bucket: ${bucketDeletionResult.message}`,
          token,
        };
      }
      return {
        status: 200,
        message: "Project and associated bucket deleted successfully",
        token,
      };
    }
  } catch (error: any) {
    console.log("Error in deleteProject:", error.message || error.toString());
    return {
      status: 500,
      message: "An error occurred while deleting the project",
      token,
    };
  }
};