// browser 层
import { AINativeModule } from '@opensumi/ide-ai-native/lib/browser';
import { DesignModule } from '@opensumi/ide-design/lib/browser';

renderApp({
  modules: [...CommonBrowserModules, DesignModule, AINativeModule]
});

// server 层
import { AINativeModule } from '@opensumi/ide-ai-native/lib/node';

startServer({
  modules: [...CommonNodeModules, AINativeModule]
});

import { AINativeCoreContribution } from '@opensumi/ide-ai-native/lib/browser/types';

@Domain(AINativeCoreContribution)
export class AiNativeContribution implements AINativeCoreContribution {
  // 在这里注册各种 AI 能力
}

const injector = new Injector();
injector.addProviders(AiNativeContribution);

opts.injector = injector;
const app = new ClientApp(opts);

@Injectable()
export class AiBackService implements IAIBackService<ReqeustResponse, ChatReadableStream> {
  // 在这里可以跟任何的大模型 API 做接口交互

  // 例如 request 可以一次性返回大模型的返回结果
  async request(
    input: string,
    options: IAIBackServiceOption,
    cancelToken?: CancellationToken
  ) {
    // TODO
  }

  // requestStream 需要返回一个 ChatReadableStream，以便前端可以流式读取模型的回答
  async requestStream(
    input: string,
    options: IAIBackServiceOption,
    cancelToken?: CancellationToken
  ) {
    const chatReadableStream = new ChatReadableStream();
    cancelToken?.onCancellationRequested(() => {
      chatReadableStream.end();
    });

    setTimeout(() => {
      chatReadableStream.emitData({ kind: 'content', content: 'Hello' });
      await sleep(10);
      chatReadableStream.emitData({ kind: 'content', content: 'OpenSumi!' });
    }, 1000);

    return chatReadableStream;
  }
}

import { AIBackSerivceToken } from '@opensumi/ide-core-common';

const injector = new Injector();
injector.addProviders({
  token: AIBackSerivceToken,
  useClass: AiBackService
});

opts.injector = injector;
const serverApp = new ServerApp(opts);

@Domain(AINativeCoreContribution)
export class AiNativeContribution implements AINativeCoreContribution {
  // 通过 AIBackSerivcePath 拿到注册好的后端服务
  // 此时就能直接 RPC 调用后端服务提供的函数
  @Autowired(AIBackSerivcePath)
  private readonly aiBackService: IAIBackService;

  registerInlineChatFeature(registry: IInlineChatFeatureRegistry) {
    registry.registerEditorInlineChat(
      {
        id: 'ai-comments',
        name: 'Comments',
        title: 'add comments',
        renderType: 'button',
        codeAction: {}
      },
      {
        execute: async (editor: IEditor) => {
          // 在这里处理 inline chat 按钮点击之后的任何交互
        }
      }
    );

    registry.registerEditorInlineChat(
      {
        id: 'ai-optimize',
        name: 'Optimize',
        renderType: 'dropdown',
        codeAction: {}
      },
      {
        // 提供 diff 预览策略
        providerDiffPreviewStrategy: async (editor: ICodeEditor, token) => {
          const crossCode = this.getCrossCode(editor);
          const prompt = `Optimize the code:\n\`\`\`\n ${crossCode}\`\`\``;

          // 在这里通过调用后端服务的 request 方法拿到大模型返回的结果
          const result = await this.aiBackService.request(prompt, {}, token);

          if (result.isCancel) {
            return new CancelResponse();
          }

          if (result.errorCode !== 0) {
            return new ErrorResponse('');
          }

          return new ReplyResponse(result.data!);
        }
      }
    );
  }
}

export class ReplyResponse {
  constructor(readonly message: string) {}

  static is(response: any): boolean {
    return (
      response instanceof ReplyResponse ||
      (typeof response === 'object' && response.message !== undefined)
    );
  }
}

export class ErrorResponse {
  constructor(readonly error: any, readonly message?: string) {}

  static is(response: any): boolean {
    return (
      response instanceof ErrorResponse ||
      (typeof response === 'object' && response.error !== undefined)
    );
  }
}

export class CancelResponse {
  readonly cancellation: boolean = true;

  constructor(readonly message?: string) {}

  static is(response: any): boolean {
    return (
      response instanceof CancelResponse ||
      (typeof response === 'object' && response.cancellation !== undefined)
    );
  }
}

export type ChatResponse = ReplyResponse | ErrorResponse | CancelResponse;

// 注册编辑器内的 inline chat
registerInlineChatFeature(registry: IInlineChatFeatureRegistry) {
 registry.registerEditorInlineChat(
   {
     id: 'comments',
     name: 'Comments',
   },
   {
     providerDiffPreviewStrategy: async (editor: ICodeEditor, token) => {
       const crossCode = this.getCrossCode(editor);
       const prompt = `Comment the code: \`\`\`\n ${crossCode}\`\`\`. It is required to return only the code results without explanation.`;

       const result = await this.aiBackService.request(prompt, {}, token);

       if (result.isCancel) {
         return new CancelResponse();
       }

       if (result.errorCode !== 0) {
         return new ErrorResponse('');
       }

       return new ReplyResponse(result.data!);
     },
   },
 );
}

// 注册终端区域的 inline chat
registry.registerTerminalInlineChat(
   {
     id: 'terminal',
     name: 'terminal',
   },
   {
     triggerRules: 'selection',
     execute: async (stdout: string) => {},
   },
);

registerChatFeature(registry: IChatFeatureRegistry): void {
 registry.registerWelcome(
   new MarkdownString(`Hello, I am your dedicated AI assistant, here to answer questions about code and help you think. You can ask me some questions about code.`),
   [
     {
       icon: getIcon('send-hollow'),
       title: 'Generate a Java Quicksort Algorithm',
       message: 'Generate a Java Quicksort Algorithm',
     },
   ],
 );

 registry.registerSlashCommand(
   {
     name: 'Explain',
     description: 'Explain',
     isShortcut: true,
     tooltip: 'Explain',
   },
   {
     providerRender: CustomSlashCommand,
     providerInputPlaceholder(value, editor) {
       return 'Please enter or paste the code.';
     },
     providerPrompt(value, editor) {
       return `Explain code: \`\`\`\n${value}\n\`\`\``;
     },
     execute: (value: string, send: TChatSlashCommandSend, editor: ICodeEditor) => {
       send(value);
     },
   },
 );
}

registerChatRender(registry: IChatRenderRegistry): void {
   // 直接注入 React 组件即可
   registry.registerWelcomeRender(CustomWelcomeComponents)
}

registerResolveConflictFeature(registry: IResolveConflictRegistry): void {
 registry.registerResolveConflictProvider('traditional', {
   providerRequest: async (contentMetadata, options, token) => {
    return new ReplyResponse('Resolved successfully!')
   },
 });
}

registerRenameProvider(registry: IRenameCandidatesProviderRegistry): void {
  registry.registerRenameSuggestionsProvider(async (model, range, token): Promise<NewSymbolName[] | undefined> => {
    return {
     newSymbolName: 'ai rename',
     tags: [NewSymbolNameTag.AIGenerated],
    }
  });
}

registerProblemFixFeature(registry: IProblemFixProviderRegistry): void {
  registry.registerHoverFixProvider({
    provideFix: async (
      editor: ICodeEditor,
      context: IProblemFixContext,
      token: CancellationToken,
    ): Promise<ChatResponse | InlineChatController> => {
      const { marker, editRange } = context;
      const prompt = '可自行组装问题诊断的 prompt';

      const controller = new InlineChatController({ enableCodeblockRender: true });
      const stream = await this.aiBackService.requestStream(prompt, {}, token);
      controller.mountReadable(stream);

      return controller;
    },
  });
}

registerIntelligentCompletionFeature(registry: IIntelligentCompletionsRegistry): void {
  registry.registerIntelligentCompletionProvider(async (editor, position, bean, token) => {
    const model = editor.getModel()!;
    const value = model.getValueInRange({
      startLineNumber: position.lineNumber,
      startColumn: 1,
      endLineNumber: position.lineNumber + 3,
      endColumn: model?.getLineMaxColumn(position.lineNumber + 3),
    });

    const cancelController = new AbortController();
    const { signal } = cancelController;

    token.onCancellationRequested(() => {
      cancelController.abort();
    });

    const getRandomString = (length) => {
      const characters = 'opensumi';
      let result = '';
      for (let i = 0; i < length; i++) {
        result += characters.charAt(Math.floor(Math.random() * characters.length));
      }
      return result;
    };

    /**
     * 随机增删字符
     */
    const insertRandomStrings = (originalString) => {
      const minChanges = 2;
      const maxChanges = 5;
      const changesCount = Math.floor(Math.random() * (maxChanges - minChanges + 1)) + minChanges;
      let modifiedString = originalString;
      for (let i = 0; i < changesCount; i++) {
        const randomIndex = Math.floor(Math.random() * originalString.length);
        const operation = Math.random() < 0.5 ? 'delete' : 'insert';
        if (operation === 'delete') {
          modifiedString = modifiedString.slice(0, randomIndex) + modifiedString.slice(randomIndex + 1);
        } else {
          const randomChar = getRandomString(1);
          modifiedString = modifiedString.slice(0, randomIndex) + randomChar + modifiedString.slice(randomIndex);
        }
      }
      return modifiedString;
    };

    try {
      await new Promise((resolve, reject) => {
        const timeout = setTimeout(resolve, 1000);

        signal.addEventListener('abort', () => {
          clearTimeout(timeout);
          reject(new DOMException('Aborted', 'AbortError'));
        });
      });

      return {
        items: [
          {
            insertText: insertRandomStrings(value),
            range: {
              startLineNumber: position.lineNumber,
              startColumn: 1,
              endLineNumber: position.lineNumber + 3,
              endColumn: model?.getLineMaxColumn(position.lineNumber + 3),
            },
          },
        ],
        // 是否启动多行补全
        enableMultiLine: true,
      };
    } catch (error) {
      if (error.name === 'AbortError') {
        return { items: [] };
      }
      throw error;
    }
  });
}