// 文件位置: src/mcp/tools/feishuTools.ts
import { z } from 'zod';

export function registerFeishuTools(server: McpServer, feishuService: FeishuApiService) {
  server.tool(
    'new_feishu_tool',
    '工具描述，说明工具的功能和使用场景',
    {
      param1: z.string().describe('参数1的说明'),
      param2: z.number().optional().describe('参数2的说明（可选）'),
    },
    async ({ param1, param2 }) => {
      try {
        // 调用 feishuService 的方法
        const result = await feishuService.someMethod(param1, param2);
        
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify(result, null, 2)
            }
          ]
        };
      } catch (error) {
        Logger.error('工具执行失败:', error);
        const errorMessage = formatErrorMessage(error);
        return {
          content: [
            {
              type: 'text',
              text: `工具执行失败: ${errorMessage}`
            }
          ]
        };
      }
    }
  );
}

// 文件位置: src/services/feishuApiService.ts
public async someMethod(param1: string, param2?: number): Promise<any> {
  try {
    const endpoint = '/some/endpoint';
    const params = { param1, param2 };
    const response = await this.get(endpoint, params);
    return response;
  } catch (error) {
    this.handleApiError(error, '操作失败');
  }
}

// 文件位置: src/services/blockFactory.ts
export enum BlockType {
  // ... 现有类型
  NEW_TYPE = 'new_type'
}

export class BlockFactory {
  createNewTypeBlock(options: NewTypeOptions): any {
    return {
      block_type: BlockTypeMap[BlockType.NEW_TYPE],
      // ... 块内容结构
    };
  }
}

// 文件位置: src/services/feishuApiService.ts
public async createNewTypeBlock(
  documentId: string,
  parentBlockId: string,
  options: NewTypeOptions,
  index: number = 0
): Promise<any> {
  const blockContent = this.blockFactory.createNewTypeBlock(options);
  return this.createDocumentBlock(documentId, parentBlockId, blockContent, index);
}

// ✅ 好的做法
interface UserInfo {
  id: string;
  name: string;
}

function getUserInfo(id: string): Promise<UserInfo> {
  // ...
}

// ❌ 不好的做法
function getUserInfo(id: any): any {
  // ...
}

/**
 * 获取用户访问令牌
 * @param clientKey 客户端缓存键
 * @param appId 应用ID（可选，如果tokenInfo中没有则使用此参数）
 * @returns 用户访问令牌
 * @throws 如果无法获取有效的token则抛出AuthRequiredError
 */
public async getUserAccessToken(
  clientKey: string,
  appId?: string,
  appSecret?: string
): Promise<string> {
  // ...
}

try {
  const result = await someAsyncOperation();
  return result;
} catch (error) {
  Logger.error('操作失败:', error);
  const errorMessage = formatErrorMessage(error);
  throw new Error(`操作失败: ${errorMessage}`);
}

server.tool('some_tool', '...', {...}, async (params) => {
  Logger.debug('工具调用参数:', params);
  
  try {
    const result = await feishuService.someMethod(params);
    Logger.debug('工具执行结果:', result);
    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
  } catch (error) {
    Logger.error('工具执行失败:', error);
    throw error;
  }
});

// 文件位置: src/services/feishuApiService.test.ts
import { describe, it, expect, beforeEach } from '@jest/globals';
import { FeishuApiService } from './feishuApiService';

describe('FeishuApiService', () => {
  let service: FeishuApiService;

  beforeEach(() => {
    service = FeishuApiService.getInstance();
  });

  it('should create document', async () => {
    const result = await service.createDocument('Test', 'folder_token');
    expect(result).toBeDefined();
    expect(result.objToken).toBeDefined();
  });
});