/**
 * Copyright IBM Corp. 2024, 2025
 */

const baseAssertion = {
  kind: 'assertion',
  metadata: {
    name: 'TestPaymentAssertion',
    namespace: 'default',
    version: '1.0.0',
  },
  spec: [
    {
      name: 'Validate the response code',
      key: 'code',
      value: 200,
      action: 'equals',
    },
  ],
};

export const validTest = {
  kind: 'test',
  metadata: {
    name: 'TestPayments',
    version: '1.0.0',
    tags: ['functional'],
    namespace: 'default',
  },
  spec: {
    api: {
      $ref: 'PaymentAPI:1.0.1',
    },
    environment: {
      $ref: 'default:TestPaymentsEnvironment:1.0.0',
    },
    request: [
      {
        method: 'POST',
        resource: 'v2/pet',
        headers: [
          {
            key: 'Content-Type',
            value: '${content-type}',
          },
        ],
        auth: {
          noauth: true,
        },
        payload: {
          raw: {
            json: '{\n  "name":"Jose"\n}\n',
          },
        },
        settings: {
          sslVerification: false,
          encodeURL: true,
        },
        assertions: [{ $ref: 'default:TestPaymentAssertion:1.0.0' }],
      },
      {
        method: '${method}',
        resource: 'v2/pet',
        headers: [
          {
            key: 'Content-Type',
            value: '${content-type}',
          },
        ],
        auth: {
          noauth: true,
        },
        payload: {
          raw: {
            json: '{\n  "name":"Adam"\n}\n',
          },
        },
        settings: {
          sslVerification: false,
          encodeURL: true,
        },
        assertions: {
          assertions: [baseAssertion],
        },
      },
    ],
  },
};

export const validTestWithIf = {
  ...validTest,
  spec: {
    ...validTest.spec,
    request: [
      {
        method: 'POST',
        resource: 'v2/pet',
        if: '${result.statusCode} == 200',
        stopOnFail: true,
        headers: [
          {
            key: 'Content-Type',
            value: '${content-type}',
          },
        ],
        auth: {
          noauth: true,
        },
        payload: {
          raw: {
            json: '{\n  "name":"Jose"\n}\n',
          },
        },
        settings: {
          sslVerification: false,
          encodeURL: true,
        },
        assertions: [{ $ref: 'default:TestPaymentAssertion:1.0.0' }],
      },
    ],
  },
};
export const validTestWithEndpoint = {
  kind: 'test',
  metadata: {
    name: 'TestPayments',
    version: '1.0.0',
    tags: ['functional'],
    namespace: 'default',
  },
  spec: {
    api: {
      $endpoint: 'www.test.com',
    },
    environment: {
      $ref: 'default:TestPaymentsEnvironment:1.0.0',
    },
    request: [
      {
        method: 'POST',
        resource: 'v2/pet',
        headers: [
          {
            key: 'Content-Type',
            value: '${content-type}',
          },
        ],
        auth: {
          noauth: true,
        },
        payload: {
          raw: {
            json: '{\n  "name":"Jose"\n}\n',
          },
        },
        settings: {
          sslVerification: false,
          encodeURL: true,
        },
        assertions: [{ $ref: 'default:TestPaymentAssertion:1.0.0' }],
      },
      {
        method: '${method}',
        resource: 'v2/pet',
        headers: [
          {
            key: 'Content-Type',
            value: '${content-type}',
          },
        ],
        auth: {
          noauth: true,
        },
        payload: {
          raw: {
            json: '{\n  "name":"Adam"\n}\n',
          },
        },
        settings: {
          sslVerification: false,
          encodeURL: true,
        },
        assertions: {
          assertions: [baseAssertion],
        },
      },
    ],
  },
};

export const validTestWithMultiAPIAndEnvironment = {
  kind: 'test',
  metadata: {
    name: 'TestPayments',
    version: '1.0.0',
    tags: ['functional'],
    namespace: 'default',
  },
  spec: {
    api: {
      $ref: ['PaymentAPI:1.0.1', 'PaymentAPI:1.0.2'],
    },
    environment: [
      { $ref: 'default:TestPaymentsEnvironment:1.0.0' },
      { $ref: 'default:TestPaymentsEnvironment:2.0.0' },
    ],
    request: [
      {
        method: 'POST',
        resource: 'v2/pet',
        headers: [
          {
            key: 'Content-Type',
            value: '${content-type}',
          },
        ],
        auth: {
          noauth: true,
        },
        payload: {
          raw: {
            json: '{\n  "name":"Jose"\n}\n',
          },
        },
        settings: {
          sslVerification: false,
          encodeURL: true,
        },
        assertions: [{ $ref: 'default:TestPaymentAssertion:1.0.0' }],
      },
      {
        method: '${method}',
        resource: 'v2/pet',
        headers: [
          {
            key: 'Content-Type',
            value: '${content-type}',
          },
        ],
        auth: {
          noauth: true,
        },
        payload: {
          raw: {
            json: '{\n  "name":"Adam"\n}\n',
          },
        },
        settings: {
          sslVerification: false,
          encodeURL: true,
        },
        assertions: {
          assertions: [baseAssertion],
        },
      },
    ],
  },
};

export const validTestWithEnvironmentsAndAssertions = {
  kind: 'test',
  metadata: {
    name: 'TestPayments',
    version: '1.0.0',
    tags: ['functional'],
    namespace: 'default',
  },
  spec: {
    api: {
      $endpoint: 'www.test.com',
    },
    environment: [
      { $ref: 'default:TestPaymentsEnvironment:1.0.0' },
      { $ref: 'default:TestPaymentsEnvironment:2.0.0' },
    ],
    request: [
      {
        method: 'POST',
        resource: 'v2/pet',
        headers: [
          {
            key: 'Content-Type',
            value: '${content-type}',
          },
        ],
        auth: {
          noauth: true,
        },
        payload: {
          raw: {
            json: '{\n  "name":"Jose"\n}\n',
          },
        },
        settings: {
          sslVerification: false,
          encodeURL: true,
        },
        assertions: [
          { $ref: 'default:TestPaymentAssertion:1.0.0' },
          { $ref: 'default:TestPaymentAssertion:2.0.0' },
        ],
      },
      {
        method: '${method}',
        resource: 'v2/pet',
        headers: [
          {
            key: 'Content-Type',
            value: '${content-type}',
          },
        ],
        auth: {
          noauth: true,
        },
        payload: {
          raw: {
            json: '{\n  "name":"Adam"\n}\n',
          },
        },
        settings: {
          sslVerification: false,
          encodeURL: true,
        },
        assertions: {
          assertions: [baseAssertion],
        },
      },
    ],
  },
};

export const validTests = [
  validTest,
  {
    ...validTest,
    metadata: {
      ...validTest.metadata,
      name: 'TestPayments2',
    },
    spec: {
      ...validTest.spec,
      environment: {
        variables: [
          {
            isSecret: false,
            key: 'key',
            value: 'value',
          },
        ],
      },
    },
  },
];

export const testWithEmptyEnvironment = {
  kind: 'test',
  metadata: {
    name: 'EmptyRefs',
    version: '1.0.0',
    tags: ['functional'],
    namespace: 'default',
  },
  spec: {
    api: {
      $ref: 'PaymentAPI:1.0.1',
    },
    environment: {
      $ref: '',
    },
    request: [
      {
        method: 'POST',
        resource: 'v2/pet',
        headers: [
          {
            key: 'Content-Type',
            value: 'application/json',
          },
        ],
        auth: {
          noauth: true,
        },
        payload: {
          raw: {
            json: '{\n  "name":"Jose"\n}\n',
          },
        },
        settings: {
          sslVerification: false,
          encodeURL: true,
        },
        assertions: [{ $ref: 'default:TestPaymentAssertion:1.0.0' }],
      },
    ],
  },
};

export const testWithEmptyAssertion = {
  kind: 'test',
  metadata: {
    name: 'EmptyRefs',
    version: '1.0.0',
    tags: ['functional'],
    namespace: 'default',
  },
  spec: {
    api: {
      $ref: 'PaymentAPI:1.0.1',
    },
    environment: {
      $ref: 'default:TestPaymentsEnvironment:1.0.0',
    },
    request: [
      {
        method: 'POST',
        resource: 'v2/pet',
        headers: [
          {
            key: 'Content-Type',
            value: 'application/json',
          },
        ],
        auth: {
          noauth: true,
        },
        payload: {
          raw: {
            json: '{\n  "name":"Jose"\n}\n',
          },
        },
        settings: {
          sslVerification: false,
          encodeURL: true,
        },
        assertions: {
          $ref: '',
        },
      },
    ],
  },
};

export const invalidTestMissingKind = {
  metadata: {
    name: 'TestPayments',
    version: '1.0.0',
    tags: ['functional'],
    namespace: 'default',
  },
  spec: {},
};

export const invalidTestSchema = {
  kind: 'test',
  metadata: {
    namespace: 'example',
    name: 'brokenTest',
    version: 1, // Invalid type
  },
  spec: {},
};

export const unsupportedKind = {
  kind: 'foo',
  metadata: {
    namespace: 'unknown',
    name: 'unsupported',
    version: '1.0',
  },
  spec: {},
};