types.ts

import React from 'react';

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

export interface ThemeContextType {
  theme: Theme;
  toggleTheme: () => void;
}

// -- Data Structures for Logic --

export interface MaterialData {
  material: string;
  quantity: number;
}

export interface FabricData {
  stacks: number;
  dimensions: {
    width: number;
    length: number;
  };
  material?: string;
  totalFabricUsed?: number;
}

export interface PatternData {
  totalPatterns: number;
  patternsPerStack: number;
  wastePercentage: number;
  stacksUsed: number;
  estimatedTimePerPattern: number | null;
}

export interface CuttingData {
  cutPieces: number;
  totalPatternsUsed: number;
  cuttingEfficiency: number;
  estimatedTimePerPiece: number | null;
}

export interface AssemblyData {
  assembledGarments: number;
  piecesPerGarment: number;
  cutPiecesUsed: number;
}

export interface SewingData {
  finalProducts: number;
  garmentsPerProduct: number;
  assembledGarmentsUsed: number;
}

export interface QCData {
  passedUnits: number;
  rejectedUnits: number;
  inputUnits: number;
  passRate: number;
}

// -- Financial & Accessory Types --

export interface CostConfig {
  materialCostPerUnit?: number;
  laborCostPerHour?: number;
  machineCostPerHour?: number;
  energyCostPerUnit?: number;
  overheadPercentage?: number;
  fixedCost?: number;
  sellingPrice?: number;
}

export interface CapacityConfig {
  // Universal
  workers?: number;
  machines?: number;
  lines?: number;
  inspectors?: number;

  // Socks Specific
  kgPerWorkerPerHour?: number;
  bobbinsPerMachinePerHour?: number;
  setupMinutesPerMachine?: number;
  pairsPerInspectorPerHour?: number;
  pairsPerWorkerPerHour?: number;
  boxesPerLinePerHour?: number;
  socksPerMachinePerHour?: number;
  batchesPerMachinePerHour?: number;
  stations?: number;
  socksPerStationPerHour?: number;

  // Uniforms Specific
  metersPerWorkerPerHour?: number;
  tables?: number;
  workersPerTable?: number;
  metersPerTablePerHour?: number;
  cadOperators?: number;
  patternsPerOperatorPerHour?: number;
  autoCutters?: number;
  piecesPerCutterPerHour?: number;
  workersPerLine?: number;
  shirtsPerLinePerHour?: number;
  shirtsPerInspectorPerHour?: number;

  // Logo/Heat Press/Ironing/Folding
  headsPerMachine?: number;
  logosPerHeadPerHour?: number;
  stampsPerMachinePerHour?: number;
  shirtsPerIronerPerHour?: number;
  shirtsPerFolderPerHour?: number;
}

export interface TimelineData {
  totalMinutes: number;
  totalHours: number;
  totalDays: number;
  isBottleneck: boolean;
  throughputPerHour: number;
}

export interface CostBreakdown {
  materialTotal: number;
  laborTotal: number;
  machineTotal: number;    // New
  energyTotal: number;     // New
  wasteTotal: number;
  overheadTotal: number;
  accessoryTotal: number;
  totalNodeCost: number;
  costPerUnit: number;
  cumulativeCostPerUnit: number; // New: Value carried forward
  profit?: number;         // New
  margin?: number;         // New
}

export interface AccessoryItem {
  id: string;
  name: string;
  enabled: boolean;
  timePerUnit: number; // minutes
  costPerUnit: number; // USD
}

export interface AccessoryData {
  accessories: AccessoryItem[];
  garmentsWithAccessories: number;
  totalAccessoryTime: number;
  totalAccessoryCost: number;
}

// -- Order Frame Types --

export interface OrderStats {
  id: string;
  label: string;
  totalCost: number;
  totalRevenue: number;
  profit: number;
  margin: number;
  totalProducts: number;
  totalTime: number;
  completion: number; // 0-100 based on nodes done vs total
  nodeCount: number;
}

export interface OrderFrameData {
  label: string;
  color: string; // Hex color for header
  width?: number;
  height?: number;
  stats?: OrderStats; // Live calculated stats injected into the frame
}

// Generic Node Data used by React Flow
export interface NodeData {
  label: string;
  timer: number; // Time in minutes

  // User-entered values (Form State)
  inputs: Record<string, any>;

  // Cost Configuration
  costConfig?: CostConfig;

  // Data flowing from upstream nodes
  incoming: Record<string, any>;

  // Calculated result
  output: Record<string, any>;

  // Financial Output
  costs?: CostBreakdown;

  // Capacity & Timeline Configuration (NEW)
  capacityConfig?: CapacityConfig;
  timeline?: TimelineData;

  // CallbacksFor Order Frames
  orderData?: OrderFrameData;

  // Template Locking
  locked?: boolean;

  // Callback
  onUpdate?: (id: string, data: Partial<NodeData>) => void;
}

export interface ViewportState {
  x: number;
  y: number;
  scale: number;
}

export interface Coordinate {
  x: number;
  y: number;
}

// -- Analytics Types --

export interface GraphStats {
  totalTime: number;
  totalProducts: number;
  totalCost: number;
  costPerGarment: number;
  breakdown: {
    material: number;
    labor: number;
    waste: number;
    overhead: number;
    accessories: number;
  }
}

export interface CriticalPathNode {
  id: string;
  label: string;
  duration: number;
  cumulativeTime: number;
}

export interface GraphAnalytics {
  criticalPath: string[];
  stats: GraphStats;
  bottleneckNodeId?: string;
}

// -- Gemini Chat Types --

export type ChatRole = 'user' | 'model';

export interface ChatMessage {
  id: string;
  role: ChatRole;
  text: string;
  timestamp: number;
  isStreaming?: boolean;
}

export interface GraphContext {
  summary: string;
  stats: GraphStats;
  nodes: {
    id: string;
    type: string;
    label: string;
    inputs: any;
    outputs: any;
    timer: number;
    costs?: CostBreakdown;
    incoming: any;
  }[];
  connections: {
    from: string;
    to: string;
  }[];
}

// -- Template & Order System Types --

export interface TemplateFilters {
  category: 'Sock' | 'Uniform';
  gender?: 'Men' | 'Women' | 'Child';
  warmth?: 'Warm' | 'Normal';
  length?: 'Long' | 'Normal' | 'Ankle';
}

export interface SavedTemplate {
  id: string;
  name: string;
  filters: TemplateFilters;
  nodes: any[]; // Using any to avoid circular dependency issues in types, mostly strict Node<NodeData>
  edges: any[];
  createdAt: string;
  updatedAt: string;
}

export interface ActiveOrder {
  id: string;
  orderNumber: string;
  name: string;
  client: string;
  quantity: number;
  deliveryDate: string;
  templateId: string;
  status: 'Draft' | 'Production' | 'Completed';
  nodes: any[];
  edges: any[];
  progress: number;
  createdAt: string;
  // Multi-variant support
  isMultiVariant?: boolean;
  variants?: OrderVariant[];
  category?: 'Sock' | 'Uniform' | string; // Ensure category is explicit
  color?: string; // Visual color for calendar lanes
}

export interface OrderVariant {
  id: string;
  name: string; // e.g., "Men's 168 Needle"
  quantity: number;
  templateId: string;
  nodes: any[];
  edges: any[];
  machineType?: string;
  sockType?: string;
  color?: string;
}