/**
 * Copyright IBM Corp. 2024, 2025
 */
import {
  Test,
  Test_Headers,
  Test_Auth,
  Test_Raw,
  Test_UrlEncodedFormData,
  Test_Parameters,
  Test_FormData,
  Test_Payload,
  Test_Settings,
  Test_Assertions,
  Test_Request,
  Test_Environment,
  Test_Spec,
} from '@apic/api-model/test/Test.js';
import {
  Environment as EnvironmentKind,
  Environment_Spec,
} from '@apic/api-model/test/Environment.js';
import { Assertion } from '@apic/api-model/test/Assertion.js';
import { Assert } from '@apic/api-model/test/common/Assert.js';
import { Variable } from '@apic/api-model/test/common/Variable.js';
import { Metadata } from '@apic/api-model/common/Metadata.js';
import { Ref } from '@apic/api-model/common/Ref.js';
export interface AssertionSummary {
  request: string;
  assertions: RunExecutionAssertion[];
}

export interface Header {
  key: string;
  value: string;
  description?: string;
}

export interface Request {
  endpoint?: string;
  method: string;
  headers?: Header[];
}

export interface Response {
  data?: string;
  responseTime?: number;
  code?: number;
  status: number;
  statusText: string;
  responseSize?: number;
  headers: Header[];
  stream?: Buffer | Uint8Array | undefined;
}

export interface TestExecutionResult {
  id?: string;
  itemName: string;
  response: Response;
  request: Request;
  assertions: RunExecutionAssertion[];
  startedAt: number;
  completedAt: number;
}

export interface RunExecutionAssertion {
  assertion: string;
  error?: RunExecutionAssertionError;
  skipped: boolean;
  action: string;
  actualValue?: any;
  expectedValue?: any;
  key: string;
  metadata?: {
    name?: string;
    version?: string;
    namespace?: string;
  };
}

export interface RunExecutionAssertionError {
  name: string;
  index?: number;
  test: string;
  message: string;
  stack: string;
}

export interface ResponseCode {
  code: number;
  name: string;
  time: number;
  size: number;
}

type SingleTestResult = {
  [assertionName: string]: {
    status: boolean;
    error?: RunExecutionAssertionError;
    actualValue?: any;
    expectedValue?: any;
  };
};

export interface ExecutionFilteredResult {
  id?: string;
  name: string;
  url?: string;
  method: string;
  header?: Header[];
  time: number;
  responseCode: ResponseCode;
  response: string;
  responseHeaders: Header[];
  allTests: SingleTestResult[];
}

export interface RunFilteredSummary {
  id: string;
  name: string;
  timestamp?: number;
  totalPass: number;
  status: string;
  startedAt?: number;
  totalFail?: number;
  totalTime?: number;
  results: ExecutionFilteredResult[];
  envMetadata?: {
    name: string;
    version: string;
    namespace: string;
  };
}

export type Environment = Required<EnvironmentKind>;
export type TestSpec = Required<Test>;
export type RequestHeader = Required<Test_Headers>;
export type RequestAuth = Partial<Test_Auth>;
export type RawData = Partial<Test_Raw>;
export type UrlEncodedFormDataItem = Required<Test_UrlEncodedFormData>;
export type RequestParameter = Required<Test_Parameters>;
export type FormDataItem = Required<Test_FormData>;
export type RequestBodyObject = Partial<Test_Payload>;
export type RequestSettting = Partial<Test_Settings>;
export type ExpType = Required<Assert>;
export type Assertions = Partial<Test_Assertions>;
export type TestAssertion = Required<Assertion>;
export type RequestItem = Required<Test_Request>;
export type TestEnvironment = Partial<Test_Environment>;
export type EnvironmentVariable = Required<Variable>;
export type ApiReference = Required<Ref>;
export type Spec = Required<Test_Spec>;
export type Env_Spec = Required<Environment_Spec>;
export type TestMetadata = Required<Metadata>;
export interface SpecObject {
  [key: string]: SpecObject | string;
}
export interface ErrorResponse {
  code: string;
  field: string;
  description: string;
}
export interface TestManagerInterface {
  processFile(buffer: Buffer): Promise<unknown[] | null>;
  processTrace(reqbody: any, reqHeader: any): Promise<any | null>;
  getCaptureId(reqbody: any, reqHeader: any): Promise<any | null>;
}