headquarter/apps/web/src/pages/config-profiles.tsx

import { useCallback, useEffect, useState } from "react";
import { ErrorState, LoadingState } from "../components/data-states";
import { Icon } from "../components/icon";
import { useMobileViewport } from "../hooks/use-mobile-viewport";
import { extractErrorMessage } from "../utils/errors";
import { MobileListView } from "../components/mobile-list-view";
import { MobileDetailView } from "../components/mobile-detail-view";
import { MobileEditView } from "../components/mobile-edit-view";
import { MobileFAB } from "../components/mobile-fab";
import {
  createConfigProfile,
  deleteConfigProfile,
  listConfigProfiles,
  previewConfigProfile,
  updateConfigProfile,
  updateProfileIncludes,
  type ConfigProfile,
  type CreateConfigProfileRequest,
  type ResolvedProfile,
} from "../api/config_profiles";
import { listProjects } from "../api/projects";
import type { Project } from "../types";
import { listToolTypes, type ToolType } from "../api/tool_types";
import { GitMountEditor } from "../components/git-mount-editor";

type Status = "loading" | "ready" | "error";
type MobileView = "list" | "detail" | "edit";

export const ConfigProfilesPage = () => {
  const isMobile = useMobileViewport();
  const [mobileView, setMobileView] = useState<MobileView>("list");
  const [status, setStatus] = useState<Status>("loading");
  const [profiles, setProfiles] = useState<ConfigProfile[]>([]);
  const [projects, setProjects] = useState<Project[]>([]);
  const [toolTypes, setToolTypes] = useState<ToolType[]>([]);

  const [selectedProfileId, setSelectedProfileId] = useState<string | null>(null);
  const [isCreating, setIsCreating] = useState(false);
  const [saveStatus, setSaveStatus] = useState<"idle" | "saving" | "saved" | "error">("idle");
  const [error, setError] = useState<string | null>(null);

  const [previewData, setPreviewData] = useState<ResolvedProfile | null>(null);
  const [previewingId, setPreviewingId] = useState<string | null>(null);

  const [formData, setFormData] = useState<CreateConfigProfileRequest>({
    name: "",
    description: "",
    env_vars: {},
    runtime_hints: {},
    mounts: [],
    git_mounts: [],
    files: {},
    is_default: false,
  });

  const [includedProfileIds, setIncludedProfileIds] = useState<string[]>([]);
  const [dragOverIndex, setDragOverIndex] = useState<number | null>(null);

  const selectedProfile = profiles.find((p) => p.id === selectedProfileId) || null;

  const loadData = useCallback(async () => {
    setStatus("loading");
    try {
      const [profs, projs, types] = await Promise.all([
        listConfigProfiles(),
        listProjects(),
        listToolTypes(),
      ]);
      setProfiles(profs || []);
      setProjects(projs || []);
      setToolTypes(types || []);
      
      setStatus("ready");
    } catch {
      setStatus("error");
    }
  }, []);

  useEffect(() => {
    void loadData();
  }, [loadData]);

  const resetForm = () => {
    setFormData({
      name: "",
      description: "",
      env_vars: {},
      runtime_hints: {},
      mounts: [],
      git_mounts: [],
      files: {},
      is_default: false,
    });
    setIncludedProfileIds([]);
    setError(null);
    setSaveStatus("idle");
    setPreviewData(null);
  };

  const populateForm = (profile: ConfigProfile) => {
    setFormData({
      name: profile.name,
      description: profile.description || undefined,
      project_id: profile.project_id || undefined,
      tool_type_id: profile.tool_type_id || undefined,
      env_vars: profile.env_vars,
      runtime_hints: profile.runtime_hints,
      mounts: profile.mounts,
      git_mounts: profile.git_mounts || [],
      files: profile.files,
      is_default: profile.is_default,
    });
    setIncludedProfileIds(
      profile.includes.map((inc: { included_profile_id: string }) => inc.included_profile_id)
    );
    setError(null);
    setSaveStatus("idle");
    setPreviewData(null);
  };

  const handleSelectProfile = (profile: ConfigProfile | null) => {
    if (profile) {
      setSelectedProfileId(profile.id);
      setIsCreating(false);
      populateForm(profile);
    } else {
      setSelectedProfileId(null);
    }
  };

  const handleCreateNew = () => {
    setSelectedProfileId(null);
    setIsCreating(true);
    resetForm();
  };

  // Include management functions
  const getIncludedProfile = (id: string): ConfigProfile | undefined => profiles.find((p) => p.id === id);

  const getScopeLabel = (profile: ConfigProfile): string => {
    if (profile.project_id && profile.tool_type_id) return "Project + Tool";
    if (profile.project_id) return "Project";
    if (profile.tool_type_id) return "Tool";
    return "Global";
  };

  // Cycle detection: returns true if adding targetId would create a cycle
  const wouldCreateCycle = (profileId: string, targetId: string, visited = new Set<string>()): boolean => {
    if (visited.has(targetId)) return true;
    const target = getIncludedProfile(targetId);
    if (!target) return false;
    const nextVisited = new Set(visited);
    nextVisited.add(targetId);
    for (const inc of target.includes) {
      if (inc.included_profile_id === profileId || wouldCreateCycle(profileId, inc.included_profile_id, nextVisited)) {
        return true;
      }
    }
    return false;
  };

  const availableProfilesForInclude = (): ConfigProfile[] => {
    const currentId = selectedProfile?.id;
    if (!currentId) return [];
    return profiles.filter((p) => {
      if (p.id === currentId) return false;
      if (includedProfileIds.includes(p.id)) return false;
      if (wouldCreateCycle(currentId, p.id)) return false;
      return true;
    });
  };

  const addInclude = (profileId: string) => {
    setIncludedProfileIds((prev) => [...prev, profileId]);
  };

  const removeInclude = (index: number) => {
    setIncludedProfileIds((prev) => prev.filter((_, i) => i !== index));
  };

  // Drag and drop handlers
  const handleDragStart = (e: React.DragEvent, index: number) => {
    e.dataTransfer.setData("text/plain", String(index));
    e.dataTransfer.effectAllowed = "move";
  };

  const handleDragOver = (e: React.DragEvent, index: number) => {
    e.preventDefault();
    e.dataTransfer.dropEffect = "move";
    setDragOverIndex(index);
  };

  const handleDragLeave = () => {
    setDragOverIndex(null);
  };

  const handleDrop = (e: React.DragEvent, dropIndex: number) => {
    e.preventDefault();
    const dragIndex = Number(e.dataTransfer.getData("text/plain"));
    if (dragIndex === dropIndex) {
      setDragOverIndex(null);
      return;
    }
    setIncludedProfileIds((prev) => {
      const newOrder = [...prev];
      const [removed] = newOrder.splice(dragIndex, 1);
      newOrder.splice(dropIndex, 0, removed);
      return newOrder;
    });
    setDragOverIndex(null);
  };

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    setError(null);
    setSaveStatus("saving");

    if (!formData.name?.trim()) {
      setError("Name is required");
      setSaveStatus("error");
      return;
    }

    try {
      if (isCreating) {
        const newProfile = await createConfigProfile(formData);
        if (includedProfileIds.length > 0) {
          await updateProfileIncludes(newProfile.id, { includes: includedProfileIds });
        }
        setIsCreating(false);
        setSelectedProfileId(newProfile.id);
        setSaveStatus("saved");
        await loadData();
        // Re-populate with the new profile data
        const refreshed = (await listConfigProfiles()).find((p) => p.id === newProfile.id);
        if (refreshed) populateForm(refreshed);
      } else if (selectedProfile) {
        await updateConfigProfile(selectedProfile.id, formData);
        await updateProfileIncludes(selectedProfile.id, { includes: includedProfileIds });
        setSaveStatus("saved");
        await loadData();
        // Refresh the selected profile data
        const refreshed = (await listConfigProfiles()).find((p) => p.id === selectedProfile.id);
        if (refreshed) populateForm(refreshed);
      }
    } catch (err) {
      setError(extractErrorMessage(err));
      setSaveStatus("error");
    }
  };

  const handleDelete = async (id: string) => {
    if (!window.confirm("Are you sure you want to delete this config profile?")) return;

    try {
      await deleteConfigProfile(id);
      if (selectedProfileId === id) {
        setSelectedProfileId(null);
        setIsCreating(false);
        resetForm();
      }
      await loadData();
    } catch {
      alert("Failed to delete config profile");
    }
  };

  const handlePreview = async (id: string) => {
    try {
      setPreviewingId(id);
      const data = await previewConfigProfile(id);
      setPreviewData(data);
    } catch {
      setError("Failed to preview config profile");
    } finally {
      setPreviewingId(null);
    }
  };

  const updateFormField = <K extends keyof CreateConfigProfileRequest>(
    key: K,
    value: CreateConfigProfileRequest[K]
  ) => {
    setFormData((prev) => ({ ...prev, [key]: value }));
    setSaveStatus("idle");
  };

  const addEnvVar = () => {
    setFormData((prev) => ({
      ...prev,
      env_vars: { ...prev.env_vars, "": "" },
    }));
    setSaveStatus("idle");
  };

  const updateEnvVar = (oldKey: string, newKey: string, value: string) => {
    setFormData((prev) => {
      const envVars = { ...prev.env_vars };
      if (oldKey !== newKey) {
        delete envVars[oldKey];
      }
      envVars[newKey] = value;
      return { ...prev, env_vars: envVars };
    });
    setSaveStatus("idle");
  };

  const removeEnvVar = (key: string) => {
    setFormData((prev) => {
      const envVars = { ...prev.env_vars };
      delete envVars[key];
      return { ...prev, env_vars: envVars };
    });
    setSaveStatus("idle");
  };

  const addFile = () => {
    setFormData((prev) => ({
      ...prev,
      files: { ...prev.files, "": "" },
    }));
    setSaveStatus("idle");
  };

  const updateFile = (oldPath: string, newPath: string, content: string) => {
    setFormData((prev) => {
      const files = { ...prev.files };
      if (oldPath !== newPath) {
        delete files[oldPath];
      }
      files[newPath] = content;
      return { ...prev, files };
    });
    setSaveStatus("idle");
  };

  const removeFile = (path: string) => {
    setFormData((prev) => {
      const files = { ...prev.files };
      delete files[path];
      return { ...prev, files };
    });
    setSaveStatus("idle");
  };

  const addMount = () => {
    setFormData((prev) => ({
      ...prev,
      mounts: [...(prev.mounts || []), { target: "/", mode: "rw", files: {} }],
    }));
    setSaveStatus("idle");
  };

  const updateMount = (index: number, updates: Partial<ConfigProfile["mounts"][0]>) => {
    setFormData((prev) => {
      const mounts = [...(prev.mounts || [])];
      mounts[index] = { ...mounts[index], ...updates };
      return { ...prev, mounts };
    });
    setSaveStatus("idle");
  };

  const removeMount = (index: number) => {
    setFormData((prev) => {
      const mounts = [...(prev.mounts || [])];
      mounts.splice(index, 1);
      return { ...prev, mounts };
    });
    setSaveStatus("idle");
  };

  const addMountFile = (mountIndex: number) => {
    setFormData((prev) => {
      const mounts = [...(prev.mounts || [])];
      mounts[mountIndex] = {
        ...mounts[mountIndex],
        files: { ...mounts[mountIndex].files, "": "" },
      };
      return { ...prev, mounts };
    });
    setSaveStatus("idle");
  };

  const updateMountFile = (
    mountIndex: number,
    oldPath: string,
    newPath: string,
    content: string
  ) => {
    setFormData((prev) => {
      const mounts = [...(prev.mounts || [])];
      const files = { ...mounts[mountIndex].files };
      if (oldPath !== newPath) {
        delete files[oldPath];
      }
      files[newPath] = content;
      mounts[mountIndex] = { ...mounts[mountIndex], files };
      return { ...prev, mounts };
    });
    setSaveStatus("idle");
  };

  const removeMountFile = (mountIndex: number, path: string) => {
    setFormData((prev) => {
      const mounts = [...(prev.mounts || [])];
      const files = { ...mounts[mountIndex].files };
      delete files[path];
      mounts[mountIndex] = { ...mounts[mountIndex], files };
      return { ...prev, mounts };
    });
    setSaveStatus("idle");
  };

  if (status === "loading") {
    return (
      <div className="container">
        <LoadingState message="Loading Config Profiles..." />
      </div>
    );
  }

  if (status === "error") {
    return (
      <div className="container">
        <ErrorState message="Failed to load Config Profiles." onRetry={loadData} />
      </div>
    );
  }

  // Mobile view rendering
  if (isMobile) {
    if (mobileView === "list") {
      return (
        <div className="mobile-page">
          <div className="mobile-page-header">
            <h1>Config Profiles</h1>
          </div>
          <MobileListView
            items={profiles.map((profile) => ({
              id: profile.id,
              title: profile.name,
              subtitle: profile.description || getScopeLabel(profile),
            }))}
            onItemClick={(id: string) => {
              setSelectedProfileId(id);
              setIsCreating(false);
              const profile = profiles.find((p) => p.id === id);
              if (profile) populateForm(profile);
              setMobileView("detail");
            }}
            onItemDelete={(id: string) => handleDelete(id)}
            emptyMessage="No config profiles yet"
          />
          <MobileFAB onClick={() => {
            setIsCreating(true);
            setSelectedProfileId(null);
            resetForm();
            setMobileView("edit");
          }} />
        </div>
      );
    }

    if (mobileView === "detail" && selectedProfile) {
      const fields = [
        { label: "Name", value: selectedProfile.name },
        { label: "Description", value: selectedProfile.description || "-" },
        { label: "Scope", value: getScopeLabel(selectedProfile) },
        { label: "Default", value: selectedProfile.is_default ? "Yes" : "No" },
        { label: "Environment Variables", value: Object.keys(selectedProfile.env_vars).length > 0 ? Object.entries(selectedProfile.env_vars).map(([k, v]) => `${k}=${v}`).join(", ") : "-" },
        { label: "Mounts", value: selectedProfile.mounts.length > 0 ? selectedProfile.mounts.map((m) => `${m.target} (${m.mode})`).join(", ") : "-" },
        { label: "Includes", value: selectedProfile.includes.length > 0 ? `${selectedProfile.includes.length} profile(s)` : "-" },
      ];

      return (
        <MobileDetailView
          title={selectedProfile.name}
          subtitle={getScopeLabel(selectedProfile)}
          fields={fields}
          onBack={() => setMobileView("list")}
          onEdit={() => {
            populateForm(selectedProfile);
            setIsCreating(false);
            setMobileView("edit");
          }}
          onDelete={() => handleDelete(selectedProfile.id)}
        />
      );
    }

    if (mobileView === "edit") {
      return (
        <MobileEditView
          title={isCreating ? "Create Profile" : "Edit Profile"}
          onCancel={() => {
            if (isCreating) {
              setMobileView("list");
            } else if (selectedProfile) {
              setMobileView("detail");
            } else {
              setMobileView("list");
            }
          }}
          onSave={() => handleSubmit({ preventDefault: () => {} } as React.FormEvent)}
          isSaving={saveStatus === "saving"}
        >
          {/* Profile form fields */}
          <div className="form-group">
            <label>Name *</label>
            <input
              type="text"
              value={formData.name}
              onChange={(e) => updateFormField("name", e.target.value)}
              placeholder="Profile name"
              required
            />
          </div>

          <div className="form-group">
            <label>Description</label>
            <textarea
              value={formData.description || ""}
              onChange={(e) => updateFormField("description", e.target.value)}
              placeholder="Optional description"
              rows={3}
            />
          </div>

          <div className="form-group">
            <label>Project</label>
            <select
              value={formData.project_id || ""}
              onChange={(e) => updateFormField("project_id", e.target.value || undefined)}
            >
              <option value="">Global (all projects)</option>
              {projects.map((project) => (
                <option key={project.id} value={project.id}>{project.name}</option>
              ))}
            </select>
          </div>

          <div className="form-group">
            <label>Tool Type</label>
            <select
              value={formData.tool_type_id || ""}
              onChange={(e) => updateFormField("tool_type_id", e.target.value || undefined)}
            >
              <option value="">Any tool type</option>
              {toolTypes.map((toolType) => (
                <option key={toolType.id} value={toolType.id}>{toolType.display_name}</option>
              ))}
            </select>
          </div>

          <div className="form-group">
            <label>
              <input
                type="checkbox"
                checked={formData.is_default || false}
                onChange={(e) => updateFormField("is_default", e.target.checked)}
              />
              Default Profile
            </label>
          </div>

          {/* Environment Variables */}
          <div className="form-group">
            <label>Environment Variables</label>
            {Object.entries(formData.env_vars || {}).map(([key, value], index) => (
              <div key={index} style={{ display: "flex", gap: "0.5rem", marginBottom: "0.5rem" }}>
                <input
                  type="text"
                  value={key}
                  onChange={(e) => {
                    const newEnvVars = { ...formData.env_vars };
                    delete newEnvVars[key];
                    newEnvVars[e.target.value] = value;
                    updateFormField("env_vars", newEnvVars);
                  }}
                  placeholder="KEY"
                  style={{ flex: 1 }}
                />
                <input
                  type="text"
                  value={value}
                  onChange={(e) => {
                    const newEnvVars = { ...formData.env_vars };
                    newEnvVars[key] = e.target.value;
                    updateFormField("env_vars", newEnvVars);
                  }}
                  placeholder="value"
                  style={{ flex: 1 }}
                />
                <button
                  type="button"
                  onClick={() => {
                    const newEnvVars = { ...formData.env_vars };
                    delete newEnvVars[key];
                    updateFormField("env_vars", newEnvVars);
                  }}
                  className="secondary-button"
                >
                  <Icon name="delete" size="sm" />
                </button>
              </div>
            ))}
            <button type="button" className="secondary-button" onClick={addEnvVar}>
              <Icon name="add" size="sm" /> Add Variable
            </button>
          </div>

          {/* Mounts */}
          <div className="form-group">
            <label>Mounts</label>
            {(formData.mounts || []).map((mount, index) => (
              <div key={index} style={{ display: "flex", gap: "0.5rem", marginBottom: "0.5rem" }}>
                <input
                  type="text"
                  value={mount.target}
                  onChange={(e) => {
                    const newMounts = [...(formData.mounts || [])];
                    newMounts[index] = { ...mount, target: e.target.value };
                    updateFormField("mounts", newMounts);
                  }}
                  placeholder="Target path"
                  style={{ flex: 1 }}
                />
                <select
                  value={mount.mode}
                  onChange={(e) => {
                    const newMounts = [...(formData.mounts || [])];
                    newMounts[index] = { ...mount, mode: e.target.value as "ro" | "rw" };
                    updateFormField("mounts", newMounts);
                  }}
                  style={{ width: "80px" }}
                >
                  <option value="ro">Read</option>
                  <option value="rw">Write</option>
                </select>
                <button
                  type="button"
                  onClick={() => {
                    const newMounts = (formData.mounts || []).filter((_, i) => i !== index);
                    updateFormField("mounts", newMounts);
                  }}
                  className="secondary-button"
                >
                  <Icon name="delete" size="sm" />
                </button>
              </div>
            ))}
            <button type="button" className="secondary-button" onClick={addMount}>
              <Icon name="add" size="sm" /> Add Mount
            </button>
          </div>
        </MobileEditView>
      );
    }

    // Fallback to list
    return (
      <div className="mobile-page">
        <div className="mobile-page-header">
          <h1>Config Profiles</h1>
        </div>
        <MobileListView
          items={profiles.map((profile) => ({
            id: profile.id,
            title: profile.name,
            subtitle: profile.description || getScopeLabel(profile),
          }))}
          onItemClick={(id: string) => {
            setSelectedProfileId(id);
            setIsCreating(false);
            const profile = profiles.find((p) => p.id === id);
            if (profile) populateForm(profile);
            setMobileView("detail");
          }}
          onItemDelete={(id: string) => handleDelete(id)}
          emptyMessage="No config profiles yet"
        />
        <MobileFAB onClick={() => {
          setIsCreating(true);
          setSelectedProfileId(null);
          resetForm();
          setMobileView("edit");
        }} />
      </div>
    );
  }

  return (
    <div className="container" style={{ display: "flex", height: "calc(100vh - 4rem)", gap: 0, padding: 0 }}>
      {/* Left Sidebar - Profile List */}
      <div
        style={{
          width: "280px",
          minWidth: "280px",
          borderRight: "1px solid var(--border)",
          display: "flex",
          flexDirection: "column",
          background: "var(--panel)",
        }}
      >
        <div style={{ padding: "1rem", borderBottom: "1px solid var(--border)" }}>
          <h2 style={{ margin: 0, fontSize: "1.125rem" }}>Config Profiles</h2>
          <p className="muted" style={{ margin: "0.25rem 0 0 0", fontSize: "0.875rem" }}>
            {profiles.length} profile{profiles.length !== 1 ? "s" : ""}
          </p>
        </div>

        <div style={{ flex: 1, overflowY: "auto", padding: "0.5rem" }}>
          {profiles.map((profile) => (
            <button
              key={profile.id}
              onClick={() => handleSelectProfile(profile)}
              style={{
                width: "100%",
                textAlign: "left",
                padding: "0.75rem 1rem",
                marginBottom: "0.25rem",
                borderRadius: "0.375rem",
                border: "none",
                background: selectedProfileId === profile.id ? "var(--brand)" : "transparent",
                color: selectedProfileId === profile.id ? "white" : "var(--ink)",
                cursor: "pointer",
                display: "flex",
                alignItems: "center",
                gap: "0.75rem",
                transition: "background 0.15s",
              }}
              onMouseEnter={(e) => {
                if (selectedProfileId !== profile.id) {
                  e.currentTarget.style.background = "#ece7df";
                }
              }}
              onMouseLeave={(e) => {
                if (selectedProfileId !== profile.id) {
                  e.currentTarget.style.background = "transparent";
                }
              }}
            >
              <div style={{ flex: 1, minWidth: 0 }}>
                <div style={{ fontWeight: 600, fontSize: "0.9375rem", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" }}>
                  {profile.name}
                  {profile.is_default && (
                    <span style={{ 
                      fontSize: "0.7rem", 
                      marginLeft: "0.5rem", 
                      opacity: 0.8,
                      textTransform: "uppercase",
                      letterSpacing: "0.025em"
                    }}>
                      default
                    </span>
                  )}
                  {profile.includes?.length > 0 && (
                    <span style={{ 
                      fontSize: "0.7rem", 
                      marginLeft: "0.5rem", 
                      opacity: 0.7,
                      background: selectedProfileId === profile.id ? "rgba(255,255,255,0.2)" : "var(--badge-bg, #f3f4f6)",
                      padding: "0.0625rem 0.375rem",
                      borderRadius: "0.25rem",
                    }}>
                      {profile.includes.length} include{profile.includes.length !== 1 ? "s" : ""}
                    </span>
                  )}
                </div>
                <div style={{ fontSize: "0.8125rem", opacity: 0.8, marginTop: "0.125rem" }}>
                  {profile.project_id && "Project scoped"}
                  {profile.tool_type_id && (profile.project_id ? " + Tool scoped" : "Tool scoped")}
                  {!profile.project_id && !profile.tool_type_id && "Global"}
                </div>
              </div>
              <button
                onClick={(e) => {
                  e.stopPropagation();
                  handleDelete(profile.id);
                }}
                style={{
                  background: "none",
                  border: "none",
                  color: selectedProfileId === profile.id ? "rgba(255,255,255,0.8)" : "var(--muted)",
                  cursor: "pointer",
                  padding: "0.25rem",
                  borderRadius: "0.25rem",
                  flexShrink: 0,
                  opacity: 0,
                }}
                className="delete-btn"
                title="Delete profile"
              >
                <Icon name="delete" size="sm" />
              </button>
            </button>
          ))}
        </div>

        <div style={{ padding: "1rem", borderTop: "1px solid var(--border)" }}>
          <button
            onClick={handleCreateNew}
            style={{
              width: "100%",
              display: "flex",
              alignItems: "center",
              justifyContent: "center",
              gap: "0.5rem",
              padding: "0.75rem",
              borderRadius: "0.5rem",
              border: "2px dashed var(--border)",
              background: "transparent",
              color: "var(--muted)",
              cursor: "pointer",
              fontWeight: 600,
              transition: "all 0.15s",
            }}
            onMouseEnter={(e) => {
              e.currentTarget.style.borderColor = "var(--brand)";
              e.currentTarget.style.color = "var(--brand)";
            }}
            onMouseLeave={(e) => {
              e.currentTarget.style.borderColor = "var(--border)";
              e.currentTarget.style.color = "var(--muted)";
            }}
          >
            <Icon name="add" size="sm" /> New Profile
          </button>
        </div>
      </div>

      {/* Right Panel - Editor */}
      <div style={{ flex: 1, overflow: "auto", padding: "1.5rem", minWidth: 0 }}>
        {!selectedProfileId && !isCreating ? (
          <div style={{ textAlign: "center", paddingTop: "4rem", color: "var(--muted)" }}>
            <div style={{ opacity: 0.3, marginBottom: "1rem" }}>
              <Icon name="folder" size="lg" />
            </div>
            <h3 style={{ margin: "0 0 0.5rem 0", fontWeight: 500 }}>Select a config profile</h3>
            <p style={{ margin: 0 }}>Choose a profile from the list to edit, or create a new one.</p>
          </div>
        ) : (
          <div>
            {/* Header */}
            <div style={{ marginBottom: "1.5rem", display: "flex", justifyContent: "space-between", alignItems: "flex-start" }}>
              <div>
                <h1 style={{ margin: "0 0 0.5rem 0", fontSize: "1.5rem" }}>
                  {isCreating ? "Create Profile" : selectedProfile?.name}
                </h1>
                {!isCreating && selectedProfile && (
                  <p className="muted" style={{ margin: 0 }}>
                    {selectedProfile.project_id && `Project: ${projects.find((p) => p.id === selectedProfile.project_id)?.name || selectedProfile.project_id}`}
                    {selectedProfile.project_id && selectedProfile.tool_type_id && " · "}
                    {selectedProfile.tool_type_id && `Tool: ${toolTypes.find((t) => t.id === selectedProfile.tool_type_id)?.display_name || selectedProfile.tool_type_id}`}
                  </p>
                )}
              </div>
              {!isCreating && selectedProfile && (
                <div style={{ display: "flex", gap: "0.5rem" }}>
                  <button
                    className="secondary-button"
                    onClick={() => handlePreview(selectedProfile.id)}
                    disabled={previewingId === selectedProfile.id}
                  >
                    {previewingId === selectedProfile.id ? (
                      <>
                        <Icon name="loading" size="sm" />
                        Previewing...
                      </>
                    ) : (
                      <>
                        <Icon name="info" size="sm" />
                        Preview
                      </>
                    )}
                  </button>
                </div>
              )}
            </div>

            {error && (
              <div className="error" style={{ marginBottom: "1rem" }}>
                {error}
              </div>
            )}

            {saveStatus === "saved" && (
              <div style={{ marginBottom: "1rem", padding: "0.75rem 1rem", background: "var(--success-bg, #dcfce7)", color: "var(--success, #166534)", borderRadius: "0.375rem", display: "flex", alignItems: "center", gap: "0.5rem" }}>
                <Icon name="success" size="sm" />
                Profile saved successfully
              </div>
            )}

            <form onSubmit={handleSubmit} className="stack" style={{ gap: "1.25rem", maxWidth: "800px" }}>
              <div className="form-group">
                <label htmlFor="profile-name">Name *</label>
                <input
                  id="profile-name"
                  type="text"
                  value={formData.name}
                  onChange={(e) => updateFormField("name", e.target.value)}
                  placeholder="e.g., Development Environment"
                  className="form-input"
                  required
                />
              </div>

              <div className="form-group">
                <label htmlFor="profile-description">Description</label>
                <input
                  id="profile-description"
                  type="text"
                  value={formData.description || ""}
                  onChange={(e) => updateFormField("description", e.target.value || undefined)}
                  placeholder="Optional description"
                  className="form-input"
                />
              </div>

              <div className="row" style={{ gap: "1rem" }}>
                <div className="form-group" style={{ flex: 1 }}>
                  <label htmlFor="profile-project">Project</label>
                  <select
                    id="profile-project"
                    value={formData.project_id || ""}
                    onChange={(e) => updateFormField("project_id", e.target.value || undefined)}
                    className="form-input"
                  >
                    <option value="">None (Global)</option>
                    {projects.map((project) => (
                      <option key={project.id} value={project.id}>
                        {project.name}
                      </option>
                    ))}
                  </select>
                </div>

                <div className="form-group" style={{ flex: 1 }}>
                  <label htmlFor="profile-tool">Tool Type</label>
                  <select
                    id="profile-tool"
                    value={formData.tool_type_id || ""}
                    onChange={(e) => updateFormField("tool_type_id", e.target.value || undefined)}
                    className="form-input"
                  >
                    <option value="">None</option>
                    {toolTypes.map((toolType) => (
                      <option key={toolType.id} value={toolType.id}>
                        {toolType.display_name}
                      </option>
                    ))}
                  </select>
                </div>
              </div>

              <div className="form-group">
                <label className="checkbox-label">
                  <input
                    type="checkbox"
                    checked={formData.is_default || false}
                    onChange={(e) => updateFormField("is_default", e.target.checked)}
                  />
                  Set as default for this scope
                </label>
              </div>

              {/* Includes Section */}
              <div className="form-section">
                <div style={{ display: "flex", alignItems: "center", justifyContent: "space-between", marginBottom: "0.75rem" }}>
                  <h4 style={{ margin: 0 }}>Includes</h4>
                  <span className="muted" style={{ fontSize: "0.875rem" }}>
                    {includedProfileIds.length} included
                  </span>
                </div>

                {includedProfileIds.length === 0 ? (
                  <p className="muted" style={{ fontSize: "0.875rem", margin: "0 0 0.75rem 0" }}>
                    No profiles included. Add profiles to compose configurations.
                  </p>
                ) : (
                  <div style={{ marginBottom: "0.75rem" }}>
                    {includedProfileIds.map((profileId, index) => {
                      const profile = getIncludedProfile(profileId);
                      if (!profile) return null;
                      return (
                        <div
                          key={`${profileId}-${index}`}
                          draggable
                          onDragStart={(e) => handleDragStart(e, index)}
                          onDragOver={(e) => handleDragOver(e, index)}
                          onDragLeave={handleDragLeave}
                          onDrop={(e) => handleDrop(e, index)}
                          style={{
                            display: "flex",
                            alignItems: "center",
                            gap: "0.5rem",
                            padding: "0.5rem 0.75rem",
                            background: dragOverIndex === index ? "var(--brand-bg, #e0e7ff)" : "var(--panel)",
                            border: "1px solid var(--border)",
                            borderRadius: "0.375rem",
                            marginBottom: "0.25rem",
                            cursor: "grab",
                            transition: "background 0.15s",
                          }}
                        >
                          <span style={{ cursor: "grab", color: "var(--muted)" }}>
                            <Icon name="drag" size="sm" />
                          </span>
                          <span style={{ flex: 1, fontWeight: 500 }}>{profile.name}</span>
                          <span
                            style={{
                              fontSize: "0.75rem",
                              padding: "0.125rem 0.375rem",
                              background: "var(--badge-bg, #f3f4f6)",
                              color: "var(--muted)",
                              borderRadius: "0.25rem",
                              textTransform: "uppercase",
                              letterSpacing: "0.025em",
                            }}
                          >
                            {getScopeLabel(profile)}
                          </span>
                          <button
                            type="button"
                            onClick={() => removeInclude(index)}
                            style={{
                              background: "none",
                              border: "none",
                              color: "var(--danger)",
                              cursor: "pointer",
                              padding: "0.25rem",
                              borderRadius: "0.25rem",
                            }}
                            title="Remove include"
                          >
                            <Icon name="delete" size="sm" />
                          </button>
                        </div>
                      );
                    })}
                  </div>
                )}

                {availableProfilesForInclude().length > 0 && (
                  <div className="form-group" style={{ marginBottom: 0 }}>
                    <select
                      value=""
                      onChange={(e) => {
                        if (e.target.value) {
                          addInclude(e.target.value);
                          e.target.value = "";
                        }
                      }}
                      className="form-input"
                    >
                      <option value="">+ Add Include...</option>
                      {availableProfilesForInclude().map((p) => (
                        <option key={p.id} value={p.id}>
                          {p.name} ({getScopeLabel(p)})
                        </option>
                      ))}
                    </select>
                  </div>
                )}
              </div>

              <div className="form-section">
                <h4 style={{ margin: "0 0 0.75rem 0" }}>Environment Variables</h4>
                {Object.entries(formData.env_vars || {}).map(([key, value], idx) => (
                  <div key={idx} className="form-row" style={{ gap: "0.5rem", marginBottom: "0.5rem" }}>
                    <input
                      type="text"
                      value={key}
                      onChange={(e) => updateEnvVar(key, e.target.value, value)}
                      placeholder="VAR_NAME"
                      className="form-input"
                      style={{ flex: 1 }}
                    />
                    <input
                      type="text"
                      value={value}
                      onChange={(e) => updateEnvVar(key, key, e.target.value)}
                      placeholder="value"
                      className="form-input"
                      style={{ flex: 1 }}
                    />
                    <button
                      type="button"
                      className="ghost-button small"
                      onClick={() => removeEnvVar(key)}
                    >
                      <Icon name="delete" size="sm" />
                    </button>
                  </div>
                ))}
                <button type="button" className="secondary-button" onClick={addEnvVar}>
                  <Icon name="add" size="sm" />
                  Add Variable
                </button>
              </div>

              <div className="form-section">
                <h4 style={{ margin: "0 0 0.75rem 0" }}>Runtime Hints</h4>
                <textarea
                  value={JSON.stringify(formData.runtime_hints || {}, null, 2)}
                  onChange={(e) => {
                    try {
                      const parsed = JSON.parse(e.target.value);
                      updateFormField("runtime_hints", parsed);
                    } catch {
                      // Invalid JSON, ignore
                    }
                  }}
                  placeholder='{"start_command": "npm start"}'
                  rows={4}
                  className="form-input"
                  style={{ fontFamily: "monospace", fontSize: "0.875rem" }}
                />
              </div>

              <div className="form-section">
                <h4 style={{ margin: "0 0 0.5rem 0" }}>Files</h4>
                <p className="muted" style={{ margin: "0 0 0.75rem 0", fontSize: "0.875rem" }}>
                  Relative paths written to the instance directory. Use Mounts below for absolute container paths.
                </p>
                {Object.entries(formData.files || {}).map(([path, content], idx) => (
                  <div key={idx} className="card" style={{ padding: "0.75rem", marginBottom: "0.5rem" }}>
                    <div style={{ display: "flex", gap: "0.5rem", marginBottom: "0.5rem" }}>
                      <input
                        type="text"
                        value={path}
                        onChange={(e) => updateFile(path, e.target.value, content)}
                        placeholder="relative/path/to/file"
                        className="form-input"
                        style={{ flex: 1 }}
                      />
                      <button
                        type="button"
                        className="ghost-button small"
                        onClick={() => removeFile(path)}
                      >
                        <Icon name="delete" size="sm" />
                      </button>
                    </div>
                    <textarea
                      value={content}
                      onChange={(e) => updateFile(path, path, e.target.value)}
                      placeholder="File content"
                      rows={3}
                      className="form-input"
                      style={{ fontFamily: "monospace", fontSize: "0.875rem" }}
                    />
                  </div>
                ))}
                <button type="button" className="secondary-button" onClick={addFile}>
                  <Icon name="add" size="sm" />
                  Add File
                </button>
              </div>

              <div className="form-section">
                <h4 style={{ margin: "0 0 0.5rem 0" }}>Mounts</h4>
                <p className="muted" style={{ margin: "0 0 0.75rem 0", fontSize: "0.875rem" }}>
                  Bind directories into the container at absolute paths. Files are relative to the mount target.
                </p>
                {(formData.mounts || []).map((mount, index) => (
                  <div key={index} className="card" style={{ padding: "1rem", marginBottom: "0.75rem" }}>
                    <div className="form-row" style={{ gap: "0.5rem", marginBottom: "0.75rem" }}>
                      <input
                        type="text"
                        value={mount.target}
                        onChange={(e) => updateMount(index, { target: e.target.value })}
                        placeholder="/target/path"
                        className="form-input"
                        style={{ flex: 1 }}
                      />
                      <select
                        value={mount.mode}
                        onChange={(e) =>
                          updateMount(index, { mode: e.target.value as "ro" | "rw" })
                        }
                        className="form-input"
                        style={{ width: "120px" }}
                      >
                        <option value="rw">Read/Write</option>
                        <option value="ro">Read-Only</option>
                      </select>
                      <button
                        type="button"
                        className="ghost-button small"
                        onClick={() => removeMount(index)}
                      >
                        <Icon name="delete" size="sm" />
                      </button>
                    </div>

                    <div style={{ marginLeft: "1rem" }}>
                      {Object.entries(mount.files).map(([path, content], idx) => (
                        <div key={idx} style={{ display: "flex", gap: "0.5rem", marginBottom: "0.5rem" }}>
                          <input
                            type="text"
                            value={path}
                            onChange={(e) =>
                              updateMountFile(index, path, e.target.value, content)
                            }
                            placeholder="relative/path"
                            className="form-input"
                            style={{ flex: 1 }}
                          />
                          <textarea
                            value={content}
                            onChange={(e) =>
                              updateMountFile(index, path, path, e.target.value)
                            }
                            placeholder="File content"
                            rows={2}
                            className="form-input"
                            style={{ flex: 2, fontFamily: "monospace", fontSize: "0.875rem" }}
                          />
                          <button
                            type="button"
                            className="ghost-button small"
                            onClick={() => removeMountFile(index, path)}
                          >
                            <Icon name="delete" size="sm" />
                          </button>
                        </div>
                      ))}
                      <button
                        type="button"
                        className="secondary-button small"
                        onClick={() => addMountFile(index)}
                        style={{ fontSize: "0.875rem" }}
                      >
                        <Icon name="add" size="sm" />
                        Add File to Mount
                      </button>
                    </div>
                  </div>
                ))}
                <button type="button" className="secondary-button" onClick={addMount}>
                  <Icon name="add" size="sm" />
                  Add Mount
                </button>
              </div>

              <div className="form-section">
                <GitMountEditor
                  mounts={formData.git_mounts || []}
                  onChange={(git_mounts) => updateFormField("git_mounts", git_mounts)}
                />
              </div>

              <div className="dialog-actions" style={{ marginTop: "1rem", position: "sticky", bottom: "1rem", background: "var(--surface)", padding: "1rem", borderRadius: "0.5rem", border: "1px solid var(--border)" }}>
                <button type="submit" disabled={saveStatus === "saving"}>
                  <Icon name={isCreating ? "add" : "save"} size="sm" />
                  {saveStatus === "saving" ? "Saving..." : isCreating ? "Create Profile" : "Save Changes"}
                </button>
                {(isCreating || saveStatus !== "idle") && (
                  <button
                    type="button"
                    onClick={() => {
                      if (isCreating) {
                        resetForm();
                      } else if (selectedProfile) {
                        populateForm(selectedProfile);
                      }
                    }}
                    className="button-secondary"
                  >
                    <Icon name="cancel" size="sm" /> Discard
                  </button>
                )}
              </div>
            </form>

            {previewData && (
              <div className="card stack" style={{ marginTop: "2rem", padding: "1rem" }}>
                <h3>Resolved Profile Preview</h3>
                <pre style={{ overflow: "auto", maxHeight: "400px", fontSize: "0.8125rem" }}>
                  {JSON.stringify(previewData, null, 2)}
                </pre>
                <button className="secondary-button" onClick={() => setPreviewData(null)}>
                  Close Preview
                </button>
              </div>
            )}
          </div>
        )}
      </div>
    </div>
  );
};