import projectModel from "../../model/project/project-model.ts";
import userModel from "../../model/user-Model.ts";
import { Types } from "mongoose";
import versionModel from "../../model/version/versionModel.ts";
import {
  existingProject,
  existingUser,
  archiveProject,
  previousVersion,
} from "../helpers/ProjecthelperFn.ts";
interface CreateProjectInput {
  projectName: string;
  projectUuid: string;
  userId: string; // user ID
  thumbnail?: string;
  sharedUsers?: string[];
  organization: string;
}
interface GetProjectsInterface {
  userId: string;
  organization: string;
}
interface DeleteProjectInterface {
  projectId: string;
  userId: string;
  organization: string;
}
export const createProject = async (data: CreateProjectInput) => {
  try {
    const {
      projectName,
      projectUuid,
      userId,
      thumbnail,
      sharedUsers,
      organization,
    } = data;
    const userExisting = await existingUser(userId, organization);
    if (!userExisting) {
      return {
        status: "user_not_found",
      };
    }
    const projectExisting = await existingProject(
      projectName,
      organization,
      userId
    );

    if (projectExisting) {
      return {
        status: "project_exists",
        project: projectExisting,
      };
    }

    const project = await projectModel(organization).create({
      projectName: projectName,
      projectUuid: projectUuid,
      createdBy: userId,
      thumbnail: thumbnail,
      sharedUsers: sharedUsers || [],
      isArchive: false,
    });
    const versionData = await previousVersion(project._id, organization);
    if (!versionData || versionData.length === 0) {
      const newVersion = await versionModel(organization).create({
        projectId: project._id,
        createdBy: userId,
        version: 0.01,
      });
      await projectModel(organization).findByIdAndUpdate(
        { _id: project._id, isArchive: false },
        { total_versions: `v-${newVersion.version.toFixed(2)}` }
      );
    }
    return {
      status: "Success",
      project: project,
    };
  } catch (error) {
    console.log("error: ", error);
    return {
      status: error,
    };
  }
};

export const GetAllProjects = async (data: GetProjectsInterface) => {
  try {
    const { userId, organization } = data;
    await existingUser(userId, organization);
    if (!existingUser) return { status: "User not found" };
    const projectDatas = await projectModel(organization)
      .find({
        isArchive: false,
      })
      .select("_id projectName createdBy thumbnail");
    if (projectDatas) return { status: "Success", Datas: projectDatas };
  } catch (error: unknown) {
    return { status: error };
  }
};

export const DeleteProject = async (data: DeleteProjectInterface) => {
  try {
    const { projectId, organization, userId } = data;
    const ExistingUser = await existingUser(userId, organization);
    if (!ExistingUser) return { status: "User not found" };
    const existingProject = await projectModel(organization).findOne({
      _id: projectId,
      createdBy: userId,
      isArchive: false,
    });
    if (!existingProject) return { status: "Project not found" };
    const updateProject = await projectModel(organization).findOneAndUpdate(
      { _id: projectId, isArchive: false },
      { isArchive: true, DeletedAt: new Date() },
      { new: true }
    );
    if (updateProject) return { status: "Success" };
  } catch (error: unknown) {
    return { status: error };
  }
};