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 { uploadProjectThumbnail } from "../blob/blobServices.ts";

interface CreateProjectInput {
  projectName: string;
  projectUuid: string;
  userId: string; // user ID
  thumbnail?: string;
  sharedUsers?: string[];
  organization: string;
}
interface GetInterface {
  userId: string; 
  organization: string;
}
export const createProject = async (data: CreateProjectInput) => {
  try {
    const {
      projectName,
      projectUuid,
      userId,
      thumbnail,
      sharedUsers,
      organization,
    } = data;

    if (
      !projectName ||
      !userId ||
      !thumbnail ||
      // !sharedUsers ||
      !organization
    )
      return { status: "All fields are required" };
    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: GetInterface) => {
  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 existingProject = async (
  projectName: string,
  organization: string,
  userId:string
) => {
  const projectData = await projectModel(organization).findOne({
    projectName: projectName,
    createdBy:userId,
    isArchive: false,
  });
  return projectData;
};

export const existingUser = async (userId: string, organization: string) => {
  if (!Types.ObjectId.isValid(userId)) {
    console.log("Invalid ObjectId format");
    return null;
  }
  const userData = await userModel(organization).findOne({
    _id: userId,
  });
  return userData; // ✅ Make sure you return it
};

export const archiveProject = async (
  projectId: string,
  organization: string
) => {
  return await projectModel(organization).findByIdAndUpdate(
    projectId,
    { isArchive: true },
    { new: true }
  );
};
export const previousVersion = async (
  projectId: string,
  organization: string
)=> {
  console.log('projectId: ', projectId);
  const result = await versionModel(organization).findOne({ projectId: projectId, isArchive: false})
  console.log('result: ', result);
    // .sort({ version: -1 });
  return result;
};