import { defineProvider, Message } from '@chatelope/plugin-sdk';

export default defineProvider({
  id: 'my-provider',
  name: 'My AI Provider',
  version: '1.0.0',

  // Configuration schema
  config: {
    apiKey: {
      type: 'string',
      label: 'API Key',
      secret: true,
      required: true,
    },
    baseUrl: {
      type: 'string',
      label: 'API URL',
      default: 'https://api.example.com',
    },
  },

  // List available models
  getModels: async (config) => {
    const response = await fetch(`${config.baseUrl}/models`, {
      headers: { Authorization: `Bearer ${config.apiKey}` },
    });
    return response.json();
  },

  // Send messages and stream response
  chat: async function* (messages: Message[], config, options) {
    const response = await fetch(`${config.baseUrl}/chat`, {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${config.apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        model: options.model,
        messages,
        stream: true,
      }),
    });

    // Stream the response
    for await (const chunk of streamResponse(response)) {
      yield { content: chunk };
    }
  },
});

interface Provider {
  id: string;
  name: string;
  version: string;
  icon?: string;

  // Configuration
  config: ConfigSchema;

  // Methods
  getModels(config: Config): Promise<Model[]>;
  chat(messages: Message[], config: Config, options: ChatOptions): AsyncGenerator<ChatChunk>;

  // Optional
  validateConfig?(config: Config): Promise<ValidationResult>;
  getUsage?(config: Config): Promise<UsageInfo>;
}

interface Message {
  role: 'user' | 'assistant' | 'system';
  content: string;
  attachments?: Attachment[];
}

interface ChatOptions {
  model: string;
  temperature?: number;
  maxTokens?: number;
  systemPrompt?: string;
}

interface ChatChunk {
  content?: string;
  done?: boolean;
  usage?: TokenUsage;
}

chat: async function* (messages, config, options) {
  const stream = await createStream(messages);

  for await (const chunk of stream) {
    yield { content: chunk.text };
  }

  yield { done: true, usage: stream.usage };
}

chat: async function* (messages, config, options) {
  try {
    // API call
  } catch (error) {
    if (error.status === 401) {
      throw new ProviderError('Invalid API key', 'auth_error');
    }
    if (error.status === 429) {
      throw new ProviderError('Rate limited', 'rate_limit');
    }
    throw new ProviderError('API error', 'api_error');
  }
}