/app/chrome-extension/entrypoints/sidepanel/composables/useWorkflowsV3.ts

/**
 * @fileoverview V3 Workflows Data Layer Composable
 * @description Provides V3 workflows data management for Sidepanel UI
 *
 * This composable wraps the V3 RPC client and provides:
 * - Flow listing, running, and deletion
 * - Run listing and event subscription
 * - Trigger management
 * - Data mapping from V3 types to UI types
 */

import { onMounted, onUnmounted, ref, type Ref } from 'vue';

import type { FlowV3 } from '@/entrypoints/background/record-replay-v3/domain/flow';
import type { RunRecordV3 } from '@/entrypoints/background/record-replay-v3/domain/events';
import type { TriggerSpec } from '@/entrypoints/background/record-replay-v3/domain/triggers';
import type { FlowId, RunId } from '@/entrypoints/background/record-replay-v3/domain/ids';
import { useRRV3Rpc } from './useRRV3Rpc';

// ==================== UI Types ====================

/** Flow type for UI display (compatible with existing WorkflowsView) */
export interface FlowLite {
  id: string;
  name: string;
  description?: string;
  meta?: {
    domain?: string;
    tags?: string[];
    bindings?: Array<{
      kind?: string; // V3 uses 'kind'
      type?: string; // V2 uses 'type'
      value: string;
    }>;
  };
}

/** Run type for UI display (compatible with existing WorkflowsView) */
export interface RunLite {
  id: string;
  flowId: string;
  startedAt: string;
  finishedAt?: string;
  /**
   * Terminal success status: true=succeeded, false=failed/canceled, undefined=in progress
   * UI should check `isInProgress` first to distinguish in-progress from failed
   */
  success?: boolean;
  /** Whether the run is still in progress (queued/running/paused) */
  isInProgress: boolean;
  status: RunRecordV3['status'];
  entries: unknown[];
}

/** Trigger type for UI display */
export interface TriggerLite {
  id: string;
  type: string; // UI uses 'type', V3 uses 'kind'
  kind: string; // V3 uses 'kind'
  flowId: string;
  enabled?: boolean;
  match?: Array<{ kind: string; value: string }>; // For URL triggers
  [key: string]: unknown;
}

// ==================== Mappers ====================

/** Convert V3 FlowV3 to UI FlowLite */
function mapFlowV3ToLite(flow: FlowV3): FlowLite {
  return {
    id: flow.id,
    name: flow.name,
    description: flow.description,
    meta: {
      tags: flow.meta?.tags,
      bindings: flow.meta?.bindings?.map((b) => ({
        kind: b.kind,
        type: b.kind, // For V2 compatibility
        value: b.value,
      })),
    },
  };
}

/** Convert V3 RunRecordV3 to UI RunLite */
function mapRunV3ToLite(run: RunRecordV3): RunLite {
  // Determine if run is in progress
  const inProgressStatuses = ['queued', 'running', 'paused'];
  const isInProgress = inProgressStatuses.includes(run.status);

  // Map V3 status to success boolean for terminal states only
  let success: boolean | undefined;
  if (run.status === 'succeeded') success = true;
  else if (run.status === 'failed' || run.status === 'canceled') success = false;
  // For in-progress states, success remains undefined

  return {
    id: run.id,
    flowId: run.flowId,
    startedAt: run.startedAt
      ? new Date(run.startedAt).toISOString()
      : new Date(run.createdAt).toISOString(),
    finishedAt: run.finishedAt ? new Date(run.finishedAt).toISOString() : undefined,
    success,
    isInProgress,
    status: run.status,
    entries: [], // V3 doesn't have entries in RunRecord, use getEvents for details
  };
}

/** Convert V3 TriggerSpec to UI TriggerLite */
function mapTriggerV3ToLite(trigger: TriggerSpec): TriggerLite {
  return {
    ...trigger,
    type: trigger.kind, // Map 'kind' to 'type' for UI compatibility
    kind: trigger.kind,
  } as TriggerLite;
}

// ==================== Composable ====================

export interface UseWorkflowsV3Options {
  /** Auto-refresh interval in ms (0 = disabled) */
  autoRefreshMs?: number;
  /** Auto-connect on mount */
  autoConnect?: boolean;
}

export interface UseWorkflowsV3Return {
  // Connection state
  connected: Ref<boolean>;
  loading: Ref<boolean>;
  error: Ref<string | null>;

  // Data
  flows: Ref<FlowLite[]>;
  runs: Ref<RunLite[]>;
  triggers: Ref<TriggerLite[]>;

  // Actions
  refresh: () => Promise<void>;
  refreshFlows: () => Promise<void>;
  refreshRuns: () => Promise<void>;
  refreshTriggers: () => Promise<void>;
  runFlow: (flowId: string) => Promise<{ runId: string } | null>;
  deleteFlow: (flowId: string) => Promise<boolean>;
  exportFlow: (flowId: string) => Promise<FlowV3 | null>;
  deleteTrigger: (triggerId: string) => Promise<boolean>;

  // V3-specific
  getFlowById: (flowId: string) => Promise<FlowV3 | null>;
  getRunEvents: (runId: string) => Promise<unknown[]>;
}

/**
 * V3 Workflows data layer composable
 */
export function useWorkflowsV3(options: UseWorkflowsV3Options = {}): UseWorkflowsV3Return {
  const { autoRefreshMs = 0, autoConnect = true } = options;

  // RPC client
  const rpc = useRRV3Rpc({ autoConnect });

  // State
  const loading = ref(false);
  const error = ref<string | null>(null);
  const flows = ref<FlowLite[]>([]);
  const runs = ref<RunLite[]>([]);
  const triggers = ref<TriggerLite[]>([]);

  // Auto-refresh timer
  let refreshTimer: ReturnType<typeof setInterval> | null = null;
  // Event subscription cleanup function
  let eventUnsubscribe: (() => void) | null = null;

  // ==================== Actions ====================

  async function refreshFlows(): Promise<void> {
    try {
      const result = (await rpc.request('rr_v3.listFlows')) as FlowV3[] | null;
      flows.value = (result || []).map(mapFlowV3ToLite);
    } catch (e) {
      console.warn('[useWorkflowsV3] Failed to refresh flows:', e);
      error.value = e instanceof Error ? e.message : String(e);
    }
  }

  async function refreshRuns(): Promise<void> {
    try {
      const result = (await rpc.request('rr_v3.listRuns')) as RunRecordV3[] | null;
      // Sort by createdAt descending (newest first)
      const sorted = (result || []).slice().sort((a, b) => b.createdAt - a.createdAt);
      runs.value = sorted.map(mapRunV3ToLite);
    } catch (e) {
      console.warn('[useWorkflowsV3] Failed to refresh runs:', e);
      error.value = e instanceof Error ? e.message : String(e);
    }
  }

  async function refreshTriggers(): Promise<void> {
    try {
      const result = (await rpc.request('rr_v3.listTriggers')) as TriggerSpec[] | null;
      triggers.value = (result || []).map(mapTriggerV3ToLite);
    } catch (e) {
      console.warn('[useWorkflowsV3] Failed to refresh triggers:', e);
      error.value = e instanceof Error ? e.message : String(e);
    }
  }

  async function refresh(): Promise<void> {
    loading.value = true;
    error.value = null;
    try {
      await Promise.all([refreshFlows(), refreshRuns(), refreshTriggers()]);
    } finally {
      loading.value = false;
    }
  }

  async function runFlow(flowId: string): Promise<{ runId: string } | null> {
    try {
      const result = (await rpc.request('rr_v3.enqueueRun', {
        flowId: flowId as FlowId,
      })) as { runId: RunId; position: number } | null;
      // Refresh runs to show the new run
      void refreshRuns();
      return result ? { runId: result.runId } : null;
    } catch (e) {
      console.warn('[useWorkflowsV3] Failed to run flow:', e);
      error.value = e instanceof Error ? e.message : String(e);
      return null;
    }
  }

  async function deleteFlow(flowId: string): Promise<boolean> {
    try {
      await rpc.request('rr_v3.deleteFlow', { flowId: flowId as FlowId });
      // Refresh flows after deletion
      void refreshFlows();
      return true;
    } catch (e) {
      console.warn('[useWorkflowsV3] Failed to delete flow:', e);
      error.value = e instanceof Error ? e.message : String(e);
      return false;
    }
  }

  async function exportFlow(flowId: string): Promise<FlowV3 | null> {
    try {
      const result = (await rpc.request('rr_v3.getFlow', {
        flowId: flowId as FlowId,
      })) as FlowV3 | null;
      return result;
    } catch (e) {
      console.warn('[useWorkflowsV3] Failed to export flow:', e);
      error.value = e instanceof Error ? e.message : String(e);
      return null;
    }
  }

  async function deleteTrigger(triggerId: string): Promise<boolean> {
    try {
      await rpc.request('rr_v3.deleteTrigger', { triggerId });
      // Refresh triggers after deletion
      void refreshTriggers();
      return true;
    } catch (e) {
      console.warn('[useWorkflowsV3] Failed to delete trigger:', e);
      error.value = e instanceof Error ? e.message : String(e);
      return false;
    }
  }

  async function getFlowById(flowId: string): Promise<FlowV3 | null> {
    try {
      return (await rpc.request('rr_v3.getFlow', {
        flowId: flowId as FlowId,
      })) as FlowV3 | null;
    } catch (e) {
      console.warn('[useWorkflowsV3] Failed to get flow:', e);
      return null;
    }
  }

  async function getRunEvents(runId: string): Promise<unknown[]> {
    try {
      return (await rpc.request('rr_v3.getEvents', {
        runId: runId as RunId,
      })) as unknown[];
    } catch (e) {
      console.warn('[useWorkflowsV3] Failed to get run events:', e);
      return [];
    }
  }

  // ==================== Lifecycle ====================

  onMounted(async () => {
    if (autoConnect) {
      await rpc.ensureConnected();
      await refresh();
    }

    // Setup auto-refresh
    if (autoRefreshMs > 0) {
      refreshTimer = setInterval(() => {
        void refresh();
      }, autoRefreshMs);
    }

    // Subscribe to all run events for real-time updates
    void rpc.subscribe(null);
    eventUnsubscribe = rpc.onEvent((event) => {
      // Refresh runs when run status changes
      const runStatusEvents = [
        'run.queued',
        'run.started',
        'run.succeeded',
        'run.failed',
        'run.canceled',
        'run.paused',
        'run.resumed',
        'run.recovered',
      ];
      if (runStatusEvents.includes(event.type)) {
        void refreshRuns();
      }
    });
  });

  onUnmounted(() => {
    // Cleanup auto-refresh timer
    if (refreshTimer) {
      clearInterval(refreshTimer);
      refreshTimer = null;
    }
    // Cleanup event subscription
    if (eventUnsubscribe) {
      eventUnsubscribe();
      eventUnsubscribe = null;
    }
    // Unsubscribe from run events
    void rpc.unsubscribe(null);
  });

  return {
    connected: rpc.connected,
    loading,
    error,
    flows,
    runs,
    triggers,
    refresh,
    refreshFlows,
    refreshRuns,
    refreshTriggers,
    runFlow,
    deleteFlow,
    exportFlow,
    deleteTrigger,
    getFlowById,
    getRunEvents,
  };
}