import { NextResponse } from "next/server";
import Model3D from "@/models/Model3D";
import Hotspot from "@/models/Hotspot";

export async function GET(
  request: Request,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const resolvedParams = await params;
    const modelId = parseInt(resolvedParams.id, 10);
    if (isNaN(modelId)) {
      console.error("Invalid model ID:", resolvedParams.id);
      return NextResponse.json({ error: "Invalid model ID" }, { status: 400 });
    }

    const model = await Model3D.findByPk(modelId, {
      include: [
        {
          model: Hotspot,
          as: "hotspots",
          attributes: ["id", "position", "normal", "title", "description"],
        },
      ],
    });

    if (!model) {
      return NextResponse.json({ error: "Model not found" }, { status: 404 });
    }

    return NextResponse.json(model);
  } catch (error) {
    console.error("Error fetching model:", error);
    return NextResponse.json({ error: "Internal Server Error" }, { status: 500 });
  }
}

export async function PUT(
  request: Request,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const resolvedParams = await params;
    const modelId = parseInt(resolvedParams.id, 10);
    if (isNaN(modelId)) {
      console.error("Invalid model ID:", resolvedParams.id);
      return NextResponse.json({ error: "Invalid model ID" }, { status: 400 });
    }

    const body = await request.json();
    const { title, description, speachtext, image, modelSrc, category, program, size, date } = body;

    // Find the model
    const model = await Model3D.findByPk(modelId);
    if (!model) {
      return NextResponse.json({ error: "Model not found" }, { status: 404 });
    }

    // Build update object with provided fields
    const updates: Record<string, string | number | undefined> = {};
    if (title !== undefined) updates.title = title;
    if (description !== undefined) updates.description = description;
    if (speachtext !== undefined) updates.speachtext = speachtext;
    if (image !== undefined) updates.image = image;
    if (modelSrc !== undefined) updates.modelSrc = modelSrc;
    if (category !== undefined) updates.category = category;
    if (program !== undefined) updates.program = program;
    if (size !== undefined) updates.size = size;
    if (date !== undefined) updates.date = date;

    // Check if there are any updates
    if (Object.keys(updates).length === 0) {
      return NextResponse.json({ error: "No fields to update" }, { status: 400 });
    }

    // Update the model
    const [affectedRows] = await Model3D.update(updates, {
      where: { id: modelId },
    });

    if (!affectedRows) {
      return NextResponse.json({ error: "Failed to update model" }, { status: 500 });
    }

    // Fetch and return the updated model
    const updatedModel = await Model3D.findByPk(modelId, {
      include: [
        {
          model: Hotspot,
          as: "hotspots",
          attributes: ["id", "position", "normal", "title", "description"],
        },
      ],
    });

    return NextResponse.json(updatedModel);
  } catch (error) {
    console.error("Error updating model:", error);
    return NextResponse.json({ error: "Failed to update model" }, { status: 500 });
  }
}

export async function DELETE(
  request: Request,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const resolvedParams = await params;
    const modelId = parseInt(resolvedParams.id, 10);
    if (isNaN(modelId)) {
      console.error("Invalid model ID:", resolvedParams.id);
      return NextResponse.json({ error: "Invalid model ID" }, { status: 400 });
    }

    const model = await Model3D.findByPk(modelId);
    if (!model) {
      return NextResponse.json({ error: "Model not found" }, { status: 404 });
    }

    // Delete all related hotspots first (foreign key constraint)
    await Hotspot.destroy({
      where: { modelId },
    });

    // Then delete the model
    await model.destroy();
    
    return NextResponse.json({ message: "Model deleted successfully" });
  } catch (error) {
    console.error("Error deleting model:", error);
    return NextResponse.json({ error: "Failed to delete model" }, { status: 500 });
  }
}
