import type { IntegrationManifest } from '../../types';
import { yourCheck } from './checks';

export const yourIntegrationManifest: IntegrationManifest = {
  // Basic info
  id: 'your-integration',
  name: 'Your Integration',
  description: 'Monitor security and compliance in Your Service',
  category: 'Cloud', // or 'Identity & Access', 'Developer Tools', etc.
  logoUrl: 'https://img.logo.dev/your-service.com?token=YOUR_TOKEN',
  docsUrl: 'https://docs.your-service.com',
  isActive: true,

  // Authentication (see Authentication Types below)
  auth: {
    type: 'oauth2', // or 'api_key', 'basic', 'custom'
    config: {
      // Auth-specific config
    },
  },

  // API configuration
  baseUrl: 'https://api.your-service.com',
  defaultHeaders: {
    'Content-Type': 'application/json',
  },

  // What this integration can do
  capabilities: ['checks'], // 'checks', 'webhook', 'sync'

  // Compliance checks this integration provides
  checks: [yourCheck],
};

auth: {
  type: 'oauth2',
  config: {
    authorizeUrl: 'https://provider.com/oauth/authorize',
    tokenUrl: 'https://provider.com/oauth/token',
    scopes: ['read:user', 'read:org'],
    pkce: false, // Set true if provider requires PKCE
    clientAuthMethod: 'body', // or 'header' for Basic Auth
    supportsRefreshToken: true, // Most OAuth providers support refresh

    // Optional: Additional OAuth params
    authorizationParams: {
      access_type: 'offline',
      prompt: 'consent',
    },

    // Admin setup instructions (shown in admin UI)
    setupInstructions: `## Platform Admin: Enable OAuth
1. Go to provider developer console
2. Create OAuth application
3. Add callback URL
4. Copy Client ID and Secret`,

    createAppUrl: 'https://provider.com/apps/new',
  },
},

run: async (ctx: CheckContext) => {
  const accessToken = ctx.accessToken; // Available for OAuth integrations
  // Use ctx.fetch() which automatically adds the Bearer token
  const data = await ctx.fetch('/api/endpoint');
};

auth: {
  type: 'api_key',
  config: {
    in: 'header', // or 'query'
    name: 'X-API-Key', // Header name or query param name
    prefix: 'Bearer ', // Optional prefix
  },
},

auth: {
  type: 'custom',
  config: {
    description: 'Service Account credentials',
    credentialFields: [
      {
        id: 'project_id',
        label: 'Project ID',
        type: 'text',
        required: true,
        placeholder: 'my-project-123',
        helpText: 'Your project identifier',
      },
      {
        id: 'api_key',
        label: 'API Key',
        type: 'password',
        required: true,
      },
      {
        id: 'region',
        label: 'Region',
        type: 'combobox', // Dropdown with custom value support
        required: true,
        options: [
          { value: 'us-east-1', label: 'US East' },
          { value: 'eu-west-1', label: 'EU West' },
        ],
      },
    ],
    setupInstructions: `## Setup Instructions
1. Go to provider settings
2. Create API credentials
3. Copy the values below`,
  },
},

run: async (ctx: CheckContext) => {
  const projectId = ctx.credentials.project_id;
  const apiKey = ctx.credentials.api_key;
  const region = ctx.credentials.region;
};

import type { IntegrationCheck, CheckContext } from '../../../types';
import { TASK_TEMPLATES } from '../../../task-mappings';

export const yourCheck: IntegrationCheck = {
  // Unique ID (kebab-case)
  id: 'your-check',

  // Display name
  name: 'Your Security Check',

  // What this check does
  description: 'Verifies security settings in Your Service',

  // Map to a compliance task template (optional)
  taskMapping: TASK_TEMPLATES.twoFactorAuth,

  // Default severity for findings
  defaultSeverity: 'medium',

  // User-configurable variables (see Variables section)
  variables: [],

  // The check logic
  run: async (ctx: CheckContext) => {
    ctx.log('Starting your check...');

    try {
      // Fetch data from the service
      const data = await ctx.fetch<YourDataType>('/api/endpoint');

      // Analyze and report findings
      if (data.securityEnabled) {
        ctx.pass({
          title: 'Security Enabled',
          resourceType: 'security-setting',
          resourceId: data.id,
          description: 'Security is properly configured',
          evidence: { setting: data.securitySetting },
        });
      } else {
        ctx.fail({
          title: 'Security Disabled',
          resourceType: 'security-setting',
          resourceId: data.id,
          severity: 'high',
          description: 'Security setting is not enabled',
          remediation: 'Enable security in Settings → Security → Enable Protection',
          evidence: { currentSetting: data.securitySetting },
        });
      }

      ctx.log('Check complete');
    } catch (error) {
      ctx.fail({
        title: 'Failed to Check Security Settings',
        resourceType: 'api-error',
        resourceId: 'unknown',
        severity: 'medium',
        description: `Could not fetch security settings: ${error.message}`,
        remediation: 'Verify your API credentials and try again',
        evidence: { error: String(error) },
      });
    }
  },
};

// Logging
ctx.log('Info message', { optional: 'metadata' });
ctx.warn('Warning message');

// HTTP requests (OAuth only - auto-adds Bearer token)
await ctx.fetch<T>('/path');
await ctx.fetchAllPages<T>('/path'); // Auto-paginate

// GraphQL (if provider supports it)
await ctx.graphql<T>(query, variables);

// Report findings
ctx.fail({
  title: 'Issue Title',
  resourceType: 'resource-type',
  resourceId: 'resource-123',
  severity: 'high', // 'critical' | 'high' | 'medium' | 'low' | 'info'
  description: 'What is wrong',
  remediation: 'How to fix it',
  evidence: { any: 'data' },
});

ctx.pass({
  title: 'Check Passed',
  resourceType: 'resource-type',
  resourceId: 'resource-123',
  description: 'What was checked',
  evidence: { any: 'data' },
});

// Access data
ctx.accessToken; // OAuth access token (if OAuth)
ctx.credentials; // All credentials as key-value object
ctx.variables; // User-configured variables
ctx.connectionId; // Current connection ID
ctx.organizationId; // Current organization ID

import type { CheckVariable } from '../../../types';

const targetReposVariable: CheckVariable = {
  id: 'target_repos',
  label: 'Repositories to Monitor',
  type: 'multi-select',
  required: true,
  helpText: 'Select which repositories to check',

  // Static options
  options: [
    { value: 'repo1', label: 'Main Repository' },
    { value: 'repo2', label: 'API Repository' },
  ],

  // OR dynamic options (fetched from API)
  fetchOptions: async (ctx) => {
    const repos = await ctx.fetch<Repo[]>('/repos');
    return repos.map((r) => ({
      value: r.name,
      label: r.full_name,
    }));
  },
};

// Use in check
export const yourCheck: IntegrationCheck = {
  id: 'your-check',
  variables: [targetReposVariable],

  run: async (ctx) => {
    const targetRepos = ctx.variables.target_repos as string[];
    // Use the user-selected repos
  },
};

// src/registry/index.ts
import { yourIntegrationManifest } from '../manifests/your-integration';

export const registry: IntegrationRegistry = {
  // ... existing
  'your-integration': yourIntegrationManifest,
};

// In manifest
auth: {
  type: 'oauth2',
  config: {
    // ...
    customSettings: [
      {
        id: 'app_name',
        label: 'App Name',
        type: 'text',
        required: true,
        helpText: 'Your app name from the provider',
        token: '{APP_NAME}', // Replaces this in authorizeUrl
      },
    ],
  },
},

import { TASK_TEMPLATES } from '../../../task-mappings';

export const yourCheck: IntegrationCheck = {
  id: 'security-check',
  taskMapping: TASK_TEMPLATES.twoFactorAuth, // Maps to 2FA task
  // ...
};

// Auto-paginate (OAuth only)
const allItems = await ctx.fetchAllPages<Item>('/items');

// Manual pagination
let pageToken: string | undefined;
const allItems: Item[] = [];

do {
  const response = await ctx.fetch<{ items: Item[]; nextPage?: string }>(
    `/items?page=${pageToken || 1}`,
  );
  allItems.push(...response.items);
  pageToken = response.nextPage;
} while (pageToken);

try {
  const data = await ctx.fetch('/endpoint');

  if (data.items.length === 0) {
    // Log, don't fail - absence of items isn't always an error
    ctx.log('No items found');
    return;
  }

  // Process data...
} catch (error) {
  const errorMessage = error instanceof Error ? error.message : String(error);
  ctx.log(`API Error: ${errorMessage}`);

  // Check for specific error types
  if (errorMessage.includes('403') || errorMessage.includes('PERMISSION_DENIED')) {
    ctx.fail({
      title: 'Permission Denied',
      resourceType: 'api-access',
      resourceId: 'credentials',
      severity: 'high',
      description: 'Your account does not have permission to access this resource',
      remediation: 'Grant the [specific role] to your account in the provider console',
      evidence: { error: errorMessage },
    });
    return;
  }

  // Generic error
  ctx.fail({
    title: 'Failed to Fetch Data',
    resourceType: 'api-error',
    resourceId: 'unknown',
    severity: 'medium',
    description: 'An error occurred while fetching data from the provider',
    remediation: 'Verify your connection is active and try again',
    evidence: { error: errorMessage },
  });
}