import { LocalServer } from 'flowmcp-server'
import { FlowMCP } from 'flowmcp'
import { SchemaImporter } from 'schemaimporter'

const schemaList = await SchemaImporter.get( { withSchema: true } )
const arrayOfSchemas = schemaList.map(({ schema }) => schema)

const { activationPayloads } = FlowMCP.prepareActivations({ arrayOfSchemas })

const localServer = new LocalServer({ silent: true })
localServer.addActivationPayloads({ activationPayloads })

await localServer.start()

localServer.setConfig({
  overwrite: {
    serverDescription: {
      name: 'My Local Server',
      description: 'CLI test server',
      version: '1.2.2'
    }
  }
})

import { RemoteServer } from 'flowmcp-server'
import { FlowMCP } from 'flowmcp'

const remoteServer = new RemoteServer({ silent: true })

// Define routes with their configuration
const arrayOfRoutes = [
  {
    routePath: '/api',
    protocol: 'sse',
  }
]

// Pre-assign schemas to routes
const objectOfSchemaArrays = {
  '/api': [...] // Your schemas here
}

// Prepare route activation payloads
const { routesActivationPayloads } = RemoteServer.prepareRoutesActivationPayloads({
  arrayOfRoutes,
  objectOfSchemaArrays,
  envObject: process.env
})

remoteServer.start({ routesActivationPayloads })

remoteServer.setConfig({
  overwrite: {
    port: 8081,
    rootUrl: 'http://mydomain.com'
  }
})

import { Deploy } from 'flowmcp-server'

// Initialize with command-line arguments and schemas
const { serverType, app, mcps, events, argvs } = Deploy.init({
  argv: process.argv,
  processEnv: process.env,
  arrayOfSchemas: [...] // Your schemas
})

// Access parsed command-line arguments
console.log('Server Type:', serverType)     // 'local' or 'remote'
console.log('Parsed Args:', argvs)          // All CLI parameters
console.log('Express App:', app)            // Express.js app (remote) or McpServer (local)
console.log('MCPs:', mcps)                  // null for local, sessions object for remote
console.log('Events:', events)              // null for local, event emitter for remote

// Start the configured server
await Deploy.start()

import { DeployAdvanced } from 'flowmcp-server'

// Initialize the advanced deployment
const { serverType, app, mcps, events, server } = DeployAdvanced.init({ silent: true })

// Define routes with their configuration
const arrayOfRoutes = [
  {
    routePath: '/crypto',
    protocol: 'sse', 
  },
  {
    routePath: '/admin',
    protocol: 'streamable',
  }
]

// Pre-assign schemas to routes (user controls filtering)
const objectOfSchemaArrays = {
  '/crypto': [
    // Crypto-related schemas only
    coinGeckoSchema,
    deFiLlamaSchema
  ],
  '/admin': [
    // Admin-only schemas
    userManagementSchema,
    systemStatsSchema
  ]
}

// Start with pre-configured routes and schemas
DeployAdvanced.start({
  arrayOfRoutes,
  objectOfSchemaArrays, 
  envObject: process.env,
  rootUrl: 'https://api.example.com',
  port: 8080
})

// Optional: Access server internals for advanced customization
console.log('Server Type:', serverType)  // 'multipleRoutes'

// Express.js app - add custom middleware, routes, etc.
app.use('/health', (req, res) => res.json({ status: 'healthy' }))

// Monitor MCP sessions - track active connections per route
Object.entries(mcps).forEach(([route, { sessionIds }]) => {
  console.log(`Route ${route}: ${Object.keys(sessionIds).length} active sessions`)
})

// Event monitoring - listen to server events
events.on('sessionCreated', ({ protocol, routePath, sessionId }) => {
  console.log(`New ${protocol} session: ${sessionId} on ${routePath}`)
})

// Direct server access - modify configuration, add routes, etc.
server.setConfig({ overwrite: { port: 9000 } })

const routes = [{
  includeNamespaces: ['coingecko'],
  excludeNamespaces: ['debug'],
  activateTags: ['production'],
  routePath: '/crypto',
  protocol: 'sse',
}]

DeployAdvanced.start({
  routes,                    // ❌ Old parameter
  arrayOfSchemas: [...],     // ❌ Global array
  envObject: process.env
})

const arrayOfRoutes = [{
  routePath: '/crypto',      // ✅ Simplified route
  protocol: 'sse',
}]

const objectOfSchemaArrays = {
  '/crypto': [...]           // ✅ Pre-filtered per route
}

DeployAdvanced.start({
  arrayOfRoutes,             // ✅ New parameter
  objectOfSchemaArrays,      // ✅ Route-specific schemas  
  envObject: process.env
})