// src/services/vendor.example-api.service.ts
import { Logger } from '../utils/logger.util.js';
import { fetchApi } from '../utils/transport.util.js';
import { ExampleApiResponse, ExampleApiRequestOptions } from './vendor.example-api.types.js';
import { createApiError, McpError } from '../utils/error.util.js';

const serviceLogger = Logger.forContext('services/vendor.example-api.service.ts');

async function get(
    param?: string,
    options: ExampleApiRequestOptions = {}
): Promise<ExampleApiResponse> {
    const methodLogger = serviceLogger.forMethod('get');
    methodLogger.debug(`Calling Example API with param: ${param}`);

    try {
        const url = `https://api.example.com/${param || 'default'}`;
        const rawData = await fetchApi<ExampleApiResponse>(url, {
            headers: options.apiKey ? { 'Authorization': `Bearer ${options.apiKey}` } : {}
        });

        methodLogger.debug('Received successful response from Example API');
        return rawData;
    } catch (error) {
        methodLogger.error('Service error fetching data', error);
        
        if (error instanceof McpError) {
            throw error;
        }
        
        throw createApiError(
            'Unexpected service error while fetching data',
            undefined,
            error
        );
    }
}

export default { get };

// src/controllers/example.controller.ts
import { Logger } from '../utils/logger.util.js';
import exampleService from '../services/vendor.example-api.service.js';
import { formatExample } from './example.formatter.js';
import { handleControllerError, buildErrorContext } from '../utils/error-handler.util.js';
import { ControllerResponse } from '../types/common.types.js';
import { config } from '../utils/config.util.js';

const logger = Logger.forContext('controllers/example.controller.ts');

export interface GetDataOptions {
    param?: string;
    includeMetadata?: boolean;
}

async function getData(
    options: GetDataOptions = {}
): Promise<ControllerResponse> {
    const methodLogger = logger.forMethod('getData');
    methodLogger.debug(`Getting data for param: ${options.param || 'default'}`, options);

    try {
        // Apply business logic and defaults
        const apiKey = config.get('EXAMPLE_API_TOKEN');
        
        // Call service layer
        const data = await exampleService.get(options.param, {
            apiKey,
            includeMetadata: options.includeMetadata ?? false
        });
        
        // Format response
        const formattedContent = formatExample(data);
        return { content: formattedContent };
        
    } catch (error) {
        throw handleControllerError(
            error,
            buildErrorContext(
                'ExampleData',
                'getData',
                'controllers/example.controller.ts@getData',
                options.param || 'default',
                { options }
            )
        );
    }
}

export default { getData };

// src/tools/example.tool.ts
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { z } from 'zod';
import { Logger } from '../utils/logger.util.js';
import { formatErrorForMcpTool } from '../utils/error.util.js';
import exampleController from '../controllers/example.controller.js';

const logger = Logger.forContext('tools/example.tool.ts');

// Define Zod schema for tool arguments
const GetDataSchema = z.object({
    param: z.string().optional().describe('Optional parameter for the API call'),
    includeMetadata: z.boolean().optional().default(false)
        .describe('Whether to include additional metadata in the response')
});

async function handleGetData(args: Record<string, unknown>) {
    const methodLogger = logger.forMethod('handleGetData');
    
    try {
        methodLogger.debug('Tool example_get_data called', args);

        // Validate arguments with Zod
        const validatedArgs = GetDataSchema.parse(args);

        // Call controller
        const result = await exampleController.getData({
            param: validatedArgs.param,
            includeMetadata: validatedArgs.includeMetadata
        });

        // Return MCP-formatted response
        return {
            content: [
                {
                    type: 'text' as const,
                    text: result.content
                }
            ]
        };
    } catch (error) {
        methodLogger.error('Tool example_get_data failed', error);
        return formatErrorForMcpTool(error);
    }
}

// Registration function following the pattern used by existing tools
function registerTools(server: McpServer) {
    const registerLogger = logger.forMethod('registerTools');
    registerLogger.debug('Registering example tools...');

    server.tool(
        'example_get_data',
        `Gets data from the Example API with optional parameter.
Use this tool to fetch example data. Returns formatted data as Markdown.`,
        GetDataSchema.shape,
        handleGetData
    );

    registerLogger.debug('Example tools registered successfully');
}

export default { registerTools };

// src/cli/example.cli.ts
import { Command } from 'commander';
import { Logger } from '../utils/logger.util.js';
import exampleController from '../controllers/example.controller.js';
import { handleCliError } from '../utils/error.util.js';

const logger = Logger.forContext('cli/example.cli.ts');

function register(program: Command) {
    const methodLogger = logger.forMethod('register');
    methodLogger.debug('Registering example CLI commands...');

    program
        .command('get-data')
        .description('Gets data from the Example API')
        .argument('[param]', 'Optional parameter for the API call')
        .option('-m, --include-metadata', 'Include additional metadata in response')
        .action(async (param, options) => {
            const actionLogger = logger.forMethod('action:get-data');
            
            try {
                actionLogger.debug('CLI get-data called', { param, options });

                const result = await exampleController.getData({
                    param,
                    includeMetadata: options.includeMetadata || false
                });

                console.log(result.content);
            } catch (error) {
                handleCliError(error);
            }
        });

    methodLogger.debug('Example CLI commands registered successfully');
}

export default { register };

// 1. Register CLI in src/cli/index.ts
import exampleCli from './example.cli.js';

export async function runCli(args: string[]) {
    // ... existing setup code ...
    
    // Register CLI commands
    exampleCli.register(program);  // Add this line
    
    // ... rest of function
}

// 2. Register Tools in src/index.ts
import exampleTools from './tools/example.tool.js';

// In the startServer function, after existing registrations:
exampleTools.registerTools(serverInstance);