config.ts

import * as fs from "fs";
import * as path from "path";
import * as os from "os";
import type { OpenSyncConfig } from "./types.js";

const CONFIG_DIR = path.join(os.homedir(), ".config", "cursor-sync");
const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
const STATE_FILE = path.join(CONFIG_DIR, "state.json");

// Default configuration
const DEFAULT_CONFIG: Partial<OpenSyncConfig> = {
  autoSync: true,
  syncToolCalls: true,
  syncThinking: false,
  debug: false,
};

/**
 * Ensure config directory exists
 */
function ensureConfigDir(): void {
  if (!fs.existsSync(CONFIG_DIR)) {
    fs.mkdirSync(CONFIG_DIR, { recursive: true });
  }
}

/**
 * Load configuration from disk
 */
export function loadConfig(): OpenSyncConfig | null {
  // Check environment variables first
  const envUrl = process.env.CURSOR_SYNC_CONVEX_URL;
  const envKey = process.env.CURSOR_SYNC_API_KEY;

  if (envUrl && envKey) {
    return {
      convexUrl: envUrl,
      apiKey: envKey,
      autoSync: process.env.CURSOR_SYNC_AUTO_SYNC !== "false",
      syncToolCalls: process.env.CURSOR_SYNC_TOOL_CALLS !== "false",
      syncThinking: process.env.CURSOR_SYNC_THINKING === "true",
      debug: process.env.CURSOR_SYNC_DEBUG === "true",
    };
  }

  // Fall back to config file
  if (!fs.existsSync(CONFIG_FILE)) {
    return null;
  }

  try {
    const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
    const config = JSON.parse(raw) as Partial<OpenSyncConfig>;
    return {
      ...DEFAULT_CONFIG,
      ...config,
    } as OpenSyncConfig;
  } catch {
    return null;
  }
}

/**
 * Save configuration to disk
 */
export function saveConfig(config: OpenSyncConfig): void {
  ensureConfigDir();
  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
}

/**
 * Clear stored configuration
 */
export function clearConfig(): void {
  if (fs.existsSync(CONFIG_FILE)) {
    fs.unlinkSync(CONFIG_FILE);
  }
}

/**
 * Get a specific config value
 */
export function getConfigValue(key: keyof OpenSyncConfig): string | boolean | undefined {
  const config = loadConfig();
  return config?.[key];
}

/**
 * Set a specific config value
 */
export function setConfigValue<K extends keyof OpenSyncConfig>(
  key: K,
  value: OpenSyncConfig[K]
): void {
  const config = loadConfig() || ({} as OpenSyncConfig);
  config[key] = value;
  saveConfig(config);
}

/**
 * Get the API URL from Convex URL
 * Converts .convex.cloud to .convex.site for HTTP endpoints
 */
export function getApiUrl(convexUrl: string): string {
  return convexUrl.replace(".convex.cloud", ".convex.site");
}

/**
 * Mask API key for display
 */
export function maskApiKey(apiKey: string): string {
  if (apiKey.length <= 12) {
    return apiKey.slice(0, 4) + "****";
  }
  return apiKey.slice(0, 4) + "****..." + apiKey.slice(-4);
}

/**
 * Session state management for tracking in-progress sessions
 */
interface StateData {
  sessions: Record<string, {
    conversationId: string;
    startedAt: number;
    prompt?: string;
    workspaceRoots: string[];
    messageCount: number;
    toolCallCount: number;
    synced: boolean;
  }>;
  lastSyncedAt?: number;
}

export function loadState(): StateData {
  ensureConfigDir();
  if (!fs.existsSync(STATE_FILE)) {
    return { sessions: {} };
  }
  try {
    return JSON.parse(fs.readFileSync(STATE_FILE, "utf-8"));
  } catch {
    return { sessions: {} };
  }
}

export function saveState(state: StateData): void {
  ensureConfigDir();
  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
}

export function getSession(conversationId: string): StateData["sessions"][string] | undefined {
  const state = loadState();
  return state.sessions[conversationId];
}

export function updateSession(
  conversationId: string,
  updates: Partial<StateData["sessions"][string]>
): void {
  const state = loadState();
  state.sessions[conversationId] = {
    ...state.sessions[conversationId],
    conversationId,
    startedAt: state.sessions[conversationId]?.startedAt || Date.now(),
    workspaceRoots: state.sessions[conversationId]?.workspaceRoots || [],
    messageCount: state.sessions[conversationId]?.messageCount || 0,
    toolCallCount: state.sessions[conversationId]?.toolCallCount || 0,
    synced: false,
    ...updates,
  };
  saveState(state);
}

export function markSessionSynced(conversationId: string): void {
  const state = loadState();
  if (state.sessions[conversationId]) {
    state.sessions[conversationId].synced = true;
    state.lastSyncedAt = Date.now();
  }
  saveState(state);
}

export function clearState(): void {
  if (fs.existsSync(STATE_FILE)) {
    fs.unlinkSync(STATE_FILE);
  }
}

export { CONFIG_DIR, CONFIG_FILE };