# Install FlowMCP Core
npm install flowmcp-core

import { FlowMCP } from './src/index.mjs'

import { FlowMCP } from './src/index.mjs'
import { Server } from '@modelcontextprotocol/sdk/server/index.js'

// Create MCP server instance
const server = new Server({
    name: 'crypto-api-server',
    version: '1.0.0'
}, {
    capabilities: { tools: {} }
})

// Define your schema
const schema = {
    namespace: 'github',
    flowMCP: '1.2.2',
    root: 'https://api.github.com',
    requiredServerParams: ['GITHUB_TOKEN'],
    headers: {
        'Authorization': 'token {{GITHUB_TOKEN}}',
        'Accept': 'application/vnd.github.v3+json'
    },
    routes: {
        getUser: {
            requestMethod: 'GET',
            description: 'Get GitHub user information',
            route: '/users/{{USER_PARAM}}',
            parameters: [
                { position: { key: "username", value: "{{USER_PARAM}}", location: "insert" }, z: { primitive: "string()", options: ["min(1)", "max(39)"] } }
            ],
            tests: [],
            modifiers: []
        }
    }
}

// Server parameters for authentication
const serverParams = {
    GITHUB_TOKEN: process.env.GITHUB_TOKEN
}

// Activate schema as MCP tools
const { mcpTools } = FlowMCP.activateServerTools({
    server,
    schema,
    serverParams,
    validate: true,
    silent: false
})

console.log('Activated tools:', Object.keys(mcpTools))
// Output: ['github__getUser']

// Validate schema structure
const validation = FlowMCP.validateSchema({ schema })
if (!validation.status) {
    console.error('Schema validation failed:', validation.messages)
    process.exit(1)
}

console.log('✅ Schema validation passed')

const userParams = { username: 'octocat' }
const serverParams = { GITHUB_TOKEN: process.env.GITHUB_TOKEN }

const result = await FlowMCP.fetch({ 
    schema, 
    userParams, 
    serverParams, 
    routeName: 'getUser' 
})

if (result.status) {
    console.log('GitHub user:', result.dataAsString)
} else {
    console.error('API request failed:', result.messages)
}

const schemas = [schema1, schema2, schema3]

// Filter by namespace and tags
const { filteredArrayOfSchemas } = FlowMCP.filterArrayOfSchemas({
    arrayOfSchemas: schemas,
    includeNamespaces: ['github'],
    excludeNamespaces: [],
    activateTags: [
        'production',        // Include schemas with 'production' tag
        'github.getUser'     // Include only this route
    ]
})

console.log('Filtered schemas:', filteredArrayOfSchemas.length)

// Generate test cases
const tests = FlowMCP.getAllTests({ schema })
console.log('Available tests:', tests.length)

// Execute all tests
for (const test of tests) {
    const result = await FlowMCP.fetch({
        schema,
        userParams: test.userParams,
        serverParams: {},
        routeName: test.routeName
    })
    console.log(`${test.routeName}:`, result.status ? '✅' : '❌')
}

// Command line: node server.mjs --includeNamespaces=github --activateTags=production
const config = FlowMCP.getArgvParameters({
    argv: process.argv,
    includeNamespaces: ['default'],
    excludeNamespaces: [],
    activateTags: []
})

console.log('CLI configuration:', config)
// Output: { includeNamespaces: ['github'], activateTags: ['production'], ... }

{
    status: boolean,      // Success/failure status
    messages: string[],   // Error messages if any
    dataAsString: string  // Response data (for fetch method)
}

const result = await FlowMCP.fetch({ schema, userParams, serverParams, routeName })

if (result.status) {
    // Success - process result.dataAsString
    const data = JSON.parse(result.dataAsString)
    console.log('Data:', data)
} else {
    // Failure - handle result.messages
    console.error('Errors:', result.messages)
}

const schema = {
    // Required fields
    namespace: 'string',      // Letters only, no special characters
    root: 'string',           // Valid HTTPS URL
    routes: {                 // At least one route required
        routeName: {
            requestMethod: 'GET|POST|PUT|DELETE',
            route: 'string',        // API endpoint path
            parameters: [],         // Parameter definitions
            modifiers: []           // Request/response modifiers
        }
    },
    
    // Optional fields
    headers: {},              // Default headers
    tags: [],                 // Schema tags for filtering
    serverParams: {}          // Server-side parameters
}