/**
 * ServiceWorker Mock System Type Definitions
 */

export interface SwMockConfig {
  enabled: boolean;
  debug: boolean;
  defaultDelay: number;
  interceptPatterns: string[];
  excludePatterns: string[];
  endpoints: Record<string, MockEndpointConfig>;
  globalDelay: number | null;
  errorRate: number;
  networkFailure: NetworkFailureConfig;
  mockDataPath: string;
  includeInterceptPrefix: boolean;
}

export interface NetworkFailureConfig {
  enabled: boolean;
  scenarios: {
    httpErrors: HttpErrorScenario;
    timeout: TimeoutScenario;
    connectionFailure: ConnectionFailureScenario;
    responseDelay: ResponseDelayScenario;
    intermittentFailure: IntermittentFailureScenario;
  };
}

export interface HttpErrorScenario {
  enabled: boolean;
  statusCodes: number[];
  rate: number;
  distribution: 'random' | 'sequential' | 'weighted';
}

export interface TimeoutScenario {
  enabled: boolean;
  duration: number;
  rate: number;
}

export interface ConnectionFailureScenario {
  enabled: boolean;
  rate: number;
}

export interface ResponseDelayScenario {
  enabled: boolean;
  minDelay: number;
  maxDelay: number;
  rate: number;
}

export interface IntermittentFailureScenario {
  enabled: boolean;
  failureDuration: number;
  recoveryDuration: number;
  rate: number;
}

export interface MockEndpointConfig {
  delay?: number;
  status?: number;
  errorRate?: number;
  errorStatus?: number;
  data?: any;
  headers?: Record<string, string>;
}

// 多响应配置相关类型定义
export interface MultiResponseConfig {
  // 默认响应（当没有匹配的条件时使用）
  default: MockResponseData;
  // 条件响应列表
  responses: ConditionalResponse[];
  // 全局配置
  global?: {
    delay?: number | [number, number];
    errorRate?: number;
    headers?: Record<string, string>;
  };
}

export interface ConditionalResponse {
  // 响应名称（用于调试和日志）
  name?: string;
  // 匹配条件
  conditions: MatchCondition[];
  // 响应数据
  response: MockResponseData;
  // 权重（用于多个条件都匹配时的优先级，数值越大优先级越高）
  weight?: number;
}

export interface MatchCondition {
  // 匹配类型
  type: 'query' | 'body' | 'header' | 'method' | 'path';
  // 匹配规则
  rule: MatchRule;
  // 匹配目标（字段名或路径）
  target: string;
  // 期望值
  value: any;
  // 是否必须匹配（默认为 true）
  required?: boolean;
}

export interface MatchRule {
  // 匹配模式
  mode: 'exact' | 'contains' | 'startsWith' | 'endsWith' | 'regex' | 'range' | 'exists';
  // 是否忽略大小写（仅对字符串匹配有效）
  ignoreCase?: boolean;
  // 正则表达式标志（仅对 regex 模式有效）
  regexFlags?: string;
}

export interface MockResponseData {
  // 响应状态码
  status?: number;
  // 响应数据
  data: any;
  // 响应头
  headers?: Record<string, string>;
  // 延迟配置
  delay?: number | [number, number];
  // 错误率
  errorRate?: number;
  // 错误状态码
  errorStatus?: number | number[];
  // 描述信息
  description?: string;
}

export interface SwMockInitOptions extends Partial<SwMockConfig> {
  workerUrl?: string;
  mockDataPath?: string;
  autoRegister?: boolean;
  scope?: string;
}

export interface SwMockStatus {
  enabled: boolean;
  debug: boolean;
  defaultDelay: number;
  globalDelay: number | null;
  interceptPatterns: string[];
  excludePatterns: string[];
  endpointsCount: number;
  serviceWorkerReady: boolean;
  mockDataPath: string;
  scope: string;
  networkFailure: {
    enabled: boolean;
    httpErrors: boolean;
    timeout: boolean;
    connectionFailure: boolean;
    responseDelay: boolean;
    intermittentFailure: boolean;
  };
}

export interface CapturedRequest {
  method: string;
  url: string;
  timestamp: string;
  headers: Record<string, string>;
  body?: any;
}

export interface MockResponse {
  status: number;
  statusText: string;
  headers: Record<string, string>;
  data: any;
}

export interface NetworkFailureInfo {
  type: 'httpError' | 'timeout' | 'connectionFailure' | 'responseDelay';
  statusCode?: number;
  duration?: number;
  delay?: number;
}

export interface SwMockPlugin {
  name: string;
  install: (swMock: SwMockInstance) => void;
}

export interface SwMockInstance {
  init(options?: SwMockInitOptions): Promise<void>;
  enable(): Promise<void>;
  disable(): Promise<void>;
  toggle(): Promise<boolean>;
  getStatus(): Promise<SwMockStatus>;
  getConfig(): Promise<SwMockConfig>;
  updateConfig(config: Partial<SwMockConfig>): Promise<void>;
  resetConfig(): Promise<void>;
  
  // Network Failure Methods
  enableNetworkFailure(): Promise<void>;
  disableNetworkFailure(): Promise<void>;
  configureNetworkFailure(config: Partial<NetworkFailureConfig>): Promise<void>;
  resetNetworkFailureState(): Promise<void>;
  
  // Scenario Methods
  enableHttpErrors(options?: Partial<HttpErrorScenario>): Promise<void>;
  enableTimeouts(options?: Partial<TimeoutScenario>): Promise<void>;
  enableConnectionFailures(options?: Partial<ConnectionFailureScenario>): Promise<void>;
  enableResponseDelays(options?: Partial<ResponseDelayScenario>): Promise<void>;
  enableIntermittentFailures(options?: Partial<IntermittentFailureScenario>): Promise<void>;
  
  // Preset Modes
  enableDevelopmentMode(): Promise<void>;
  enableTestingMode(): Promise<void>;
  enableStressTestMode(): Promise<void>;
  
  // Debug and Monitoring
  enableDebug(): Promise<void>;
  disableDebug(): Promise<void>;
  startCapture(): Promise<void>;
  stopCapture(): Promise<CapturedRequest[]>;
  exportCapturedRequests(): void;
  
  // Endpoint Management
  addMockEndpoint(endpoint: string, config: MockEndpointConfig): Promise<void>;
  removeMockEndpoint(endpoint: string): Promise<void>;
  setGlobalDelay(delay: number): Promise<void>;
  
  // Pattern Management
  addInterceptPattern(pattern: string): Promise<void>;
  removeInterceptPattern(pattern: string): Promise<void>;
  addExcludePattern(pattern: string): Promise<void>;
  removeExcludePattern(pattern: string): Promise<void>;
  
  // Utility Methods
  clearDatabase(): Promise<void>;
  use(plugin: SwMockPlugin): void;
  
  // Events
  on(event: string, callback: Function): void;
  off(event: string, callback: Function): void;
  emit(event: string, ...args: any[]): void;
}

export type SwMockEventType = 
  | 'init'
  | 'enable'
  | 'disable'
  | 'config-update'
  | 'network-failure-trigger'
  | 'request-intercepted'
  | 'mock-response-sent'
  | 'error';

export interface SwMockEvent {
  type: SwMockEventType;
  timestamp: number;
  data?: any;
}

// 请求上下文信息
export interface RequestContext {
  method: string;
  url: string;
  pathname: string;
  query: Record<string, string | string[]>;
  headers: Record<string, string>;
  body?: any;
  timestamp: number;
}

// 匹配结果
export interface MatchResult {
  matched: boolean;
  response?: MockResponseData;
  matchedConditions?: string[];
  weight?: number;
  responseName?: string;
}

// Global type augmentation for window object
declare global {
  interface Window {
    SwMock?: SwMockInstance;
    swMock?: SwMockInstance;
    swMockUtils?: SwMockInstance;
  }
}