types.ts

import React from 'react';
import type * as LucideIcons from 'lucide-react';

export type LucideIconName = keyof typeof LucideIcons;

export type Theme = 'light' | 'dark';

// Agent & Automation Types
export type AgentStatus = 'idle' | 'running' | 'paused' | 'finished' | 'error';

export interface AgentLogEntry {
  type: 'thought' | 'action' | 'system' | 'error';
  content: string;
  timestamp: string;
}

export interface AgentInstance {
  id: number;
  name: string;
  goal: string;
  status: AgentStatus;
  logs: AgentLogEntry[];
}

export type AutomationActionType = 'openWindow' | 'closeWindow' | 'setTheme' | 'setWallpaper' | 'browseUrl' | 'askAssistant';
export interface AutomationStep {
    type: AutomationActionType;
    args: Record<string, any>;
}
export interface Automation {
    id: number;
    name: string;
    steps: AutomationStep[];
    schedule?: {
        type: 'once' | 'interval';
        time?: string; // ISO string for 'once'
        interval?: number; // minutes for 'interval'
    };
    lastRun?: string; // ISO string
}

// File System & Drag-and-Drop Types
export interface FileData {
  type: 'file';
  name: string;
  content: string;
  mimeType?: string; // Add optional mimeType for images
}

export interface DirectoryData {
  type: 'directory';
  name: string;
  children: FileSystemNode[];
}

export type FileSystemNode = FileData | DirectoryData;

export interface DragItem {
    type: 'file';
    payload: FileData;
}

export interface GeneratedApp {
    appName: string;
    appId: string;
    lucideIconName: LucideIconName;
    description: string;
    keywords: string[];
    code: string;
    defaultWidth?: number;
    defaultHeight?: number;
}

export type DynamicUiNode = {
  type: 'div' | 'p' | 'button' | 'input' | 'label' | 'h1' | 'h2' | 'span' | 'img';
  props?: {
    className?: string;
    placeholder?: string;
    type?: 'text' | 'password' | 'email' | 'submit' | 'button' | 'checkbox';
    htmlFor?: string;
    src?: string;
    alt?: string;
    [key: string]: any; // Allows for other valid HTML attributes
  };
  children?: (DynamicUiNode | string)[];
};

export interface AgentUIState {
  isRunning: boolean;
  status: 'thinking' | 'executing' | 'idle' | 'finished' | 'error';
  thought?: string;
  virtualCursor: { x: number; y: number };
  error?: string;
  highlightedRect?: { x: number; y: number; width: number; height: number } | null;
  originalPrompt?: string;
  actionHistory?: string[];
}

export interface NotificationInstance {
  id: number;
  title: string;
  message: string;
  icon?: React.ReactNode;
  type?: 'info' | 'suggestion';
  onClick?: () => void;
}

export interface CustomTheme {
  id: number;
  name: string;
  mode: 'light' | 'dark';
  colors: {
    glassBgLight: string; // rgba format
    glassBorderLight: string; // rgba format
    glassBgDark: string; // rgba format
    glassBorderDark: string; // rgba format
  };
}

// Widget Types
export interface WidgetInstance {
  instanceId: number;
  widgetId: string;
  x: number;
  y: number;
  zIndex: number;
}

export interface WidgetDefinition {
    id: string;
    title: string;
    component: React.ComponentType<WidgetProps>;
    defaultSize: { width: number; height: number };
}

export interface WidgetProps {
    os: OS_API;
    instance: WidgetInstance;
}

export type CustomWidgetType = 'clock' | 'text' | 'image' | 'note';

export interface CustomWidgetConfig {
  id: string;
  name: string;
  type: CustomWidgetType;
  defaultSize: { width: number; height: number };
  style: {
    backgroundColor: string; // rgba or hex
    textColor: string;
    fontSize: number;
    fontFamily: string;
    borderRadius: number;
    borderWidth: number;
    borderColor: string;
    textAlign: 'left' | 'center' | 'right';
    padding: number;
  };
  content: {
    text?: string; // For text/note
    imageUrl?: string; // For image
    clockShowDate?: boolean; // For clock
    clockShowSeconds?: boolean; // For clock
  };
}

export interface AppIconDefinition {
  type: 'lucide' | 'url';
  value: string; // LucideIconName or image URL
}

export interface OS_API {
  openWindow: (appId: string, initialProps?: Record<string, any>) => boolean;
  closeWindow: (id: number) => void;
  closeWindowByAppId: (appId: string) => boolean;
  focusWindowByAppId: (appId: string) => boolean;
  windows: WindowInstance[];
  apps: AppDefinition[];
  theme: Theme;
  setTheme: (theme: Theme) => void;
  setWallpaper: (url: string) => void;
  lockScreen: () => void;
  
  // App Generation & Management
  addApp: (appData: GeneratedApp) => Promise<boolean>;
  updateAppDefinition: (appId: string, updates: Partial<Omit<AppDefinition, 'id' | 'component'>>) => void;

  // Autonomous Agents
  agents: AgentInstance[];
  createAgent: (name: string, goal: string) => void;
  updateAgent: (id: number, updates: Partial<Omit<AgentInstance, 'id'>>) => void;
  deleteAgent: (id: number) => void;
  
  // Automations
  automations: Automation[];
  createAutomation: (name: string, steps: AutomationStep[], schedule?: Automation['schedule']) => void;
  updateAutomation: (id: number, updates: Partial<Omit<Automation, 'id'>>) => void;
  deleteAutomation: (id: number) => void;
  runAutomation: (id: number) => boolean;

  // UI Agent
  startAgentTask: (prompt: string) => void;
  stopAgentTask: () => void;
  agentState: AgentUIState;
  
  // Notifications
  notifications: NotificationInstance[];
  addNotification: (title: string, message: string, icon?: React.ReactNode, type?: NotificationInstance['type'], onClick?: () => void) => void;

  // Drag and Drop
  draggingItem: DragItem | null;
  setDraggingItem: (item: DragItem | null) => void;
  onFileDrop: (windowId: number, file: FileData) => void;
  
  // File System
  getFileSystem: () => DirectoryData;
  saveFile: (path: string, content: string, mimeType?: string) => void;
  createDirectory: (path: string) => void;
  readFile: (filePath: string) => string | null;
  listFiles: (path: string) => { type: 'file' | 'directory', name: string }[];

  // Window Management
  setWindowConfig: (id: number, config: Partial<Pick<WindowInstance, 'onBeforeClose'>>) => void;
  updateWindowData: (id: number, data: Record<string, any>) => void;
  
  // Browser
  browseUrl: (url: string) => void;

  // Custom Themes
  getCustomThemes: () => CustomTheme[];
  saveCustomTheme: (theme: Omit<CustomTheme, 'id'> & { id?: number }) => void;
  deleteCustomTheme: (id: number) => void;
  applyCustomTheme: (id: number | null) => void; // null to reset to default

  // Widgets
  widgets: WidgetInstance[];
  availableWidgets: WidgetDefinition[];
  addWidget: (widgetId: string) => void;
  removeWidget: (instanceId: number) => void;
  updateWidgetPosition: (instanceId: number, pos: { x: number; y: number }) => void;
  focusWidget: (instanceId: number) => void;
  
  // Custom Widgets
  customWidgetDefs: CustomWidgetConfig[];
  saveCustomWidget: (config: CustomWidgetConfig) => void;
  deleteCustomWidget: (id: string) => void;

  // Global Search
  toggleGlobalSearch: () => void;
  
  geminiApiKey?: string;
}

export interface AppProps {
  os: OS_API;
  initialProps?: Record<string, any>;
  isFocused?: boolean;
  windowId: number;
}

export interface AppDefinition {
  id: string;
  title: string;
  icon: AppIconDefinition;
  component: React.ComponentType<AppProps>;
  description?: string;
  keywords?: string[];
  defaultSize?: { width: number; height: number };
  isDesktopIcon?: boolean;
  resizable?: boolean;
  maximizable?: boolean;
  minimizable?: boolean;
}

export interface WindowInstance {
  id: number;
  appId: string;
  title: string;
  icon: AppIconDefinition;
  x: number;
  y: number;
  width: number;
  height: number;
  zIndex: number;
  isMinimized: boolean;
  isMaximized: boolean;
  lastPosition?: { x: number; y: number; width: number; height: number };
  initialProps?: Record<string, any>;
  onBeforeClose?: () => Promise<boolean>;
  data?: Record<string, any>;
}