import { HonoServerPlugin } from '@objectstack/plugin-hono-server';
import { ObjectKernel } from '@objectstack/runtime';

const kernel = new ObjectKernel();

// Register the server plugin
kernel.use(new HonoServerPlugin({
  port: 3000,
  staticRoot: './public'  // Optional: serve static files
}));

await kernel.bootstrap();

// Server starts automatically when kernel is ready
// API available at: http://localhost:3000/api/v1

const plugin = new HonoServerPlugin({
  port: process.env.PORT || 8080
});

kernel.use(plugin);

interface HonoPluginOptions {
  /**
   * HTTP server port
   * @default 3000
   */
  port?: number;
  
  /**
   * Path to static files directory (optional)
   */
  staticRoot?: string;
  
  /**
   * REST server configuration
   * Controls automatic endpoint generation and API behavior
   */
  restConfig?: RestServerConfig;
  
  /**
   * Whether to register standard ObjectStack CRUD endpoints
   * @default true
   */
  registerStandardEndpoints?: boolean;
  
  /**
   * Whether to load endpoints from API Registry
   * When enabled, routes are loaded dynamically from the API Registry
   * When disabled, uses legacy static route registration
   * @default true
   */
  useApiRegistry?: boolean;
}

import { createApiRegistryPlugin } from '@objectstack/core';
import { HonoServerPlugin } from '@objectstack/plugin-hono-server';

const kernel = new ObjectKernel();

// 1. Register API Registry Plugin first
kernel.use(createApiRegistryPlugin({
  conflictResolution: 'priority' // Handle route conflicts by priority
}));

// 2. Register Hono Server Plugin
kernel.use(new HonoServerPlugin({
  port: 3000,
  useApiRegistry: true,
  registerStandardEndpoints: true,
  restConfig: {
    api: {
      version: 'v1',
      basePath: '/api',
      enableCrud: true,
      enableMetadata: true,
      enableBatch: true
    }
  }
}));

await kernel.bootstrap();

new HonoServerPlugin({
  restConfig: {
    api: {
      version: 'v2',
      basePath: '/api',
      enableCrud: true,
      enableMetadata: true,
      enableBatch: true,
      enableDiscovery: true
    },
    crud: {
      dataPrefix: '/data',
      operations: {
        create: true,
        read: true,
        update: true,
        delete: true,
        list: true
      }
    },
    metadata: {
      prefix: '/meta',
      enableCache: true,
      cacheTtl: 3600
    },
    batch: {
      maxBatchSize: 200,
      operations: {
        createMany: true,
        updateMany: true,
        deleteMany: true,
        upsertMany: true
      }
    }
  }
})

// No API Registry needed for simple setups
const kernel = new ObjectKernel();

kernel.use(new HonoServerPlugin({
  port: 3000,
  useApiRegistry: false  // Explicitly disable API Registry
}));

await kernel.bootstrap();
// All standard routes registered statically

export class MyPlugin implements Plugin {
  name = 'my-custom-plugin';
  
  async start(ctx: PluginContext) {
    const httpServer = ctx.getService<IHttpServer>('http-server');
    
    // Add custom routes
    httpServer.get('/api/custom', (req, res) => {
      res.json({ message: 'Custom endpoint' });
    });
  }
}

export class MyApiPlugin implements Plugin {
  name = 'my-api-plugin';
  version = '1.0.0';
  
  async init(ctx: PluginContext) {
    const apiRegistry = ctx.getService<ApiRegistry>('api-registry');
    
    apiRegistry.registerApi({
      id: 'my_custom_api',
      name: 'My Custom API',
      type: 'rest',
      version: 'v1',
      basePath: '/api/v1/custom',
      endpoints: [
        {
          id: 'get_custom_data',
          method: 'GET',
          path: '/api/v1/custom/data',
          summary: 'Get custom data',
          priority: 500, // Lower than core endpoints (950)
          responses: [{
            statusCode: 200,
            description: 'Custom data retrieved'
          }]
        }
      ],
      metadata: {
        pluginSource: 'my-api-plugin',
        status: 'active',
        tags: ['custom']
      }
    });
    
    ctx.logger.info('Custom API endpoints registered');
  }
  
  async start(ctx: PluginContext) {
    // Bind the actual handler implementation
    const httpServer = ctx.getService<IHttpServer>('http-server');
    
    httpServer.get('/api/v1/custom/data', async (req, res) => {
      res.json({ data: 'my custom data' });
    });
  }
}

// In another plugin's manifest
capabilities: {
  extensions: [
    {
      targetPluginId: 'com.objectstack.server.hono',
      extensionPointId: 'com.objectstack.server.hono.extension.middleware',
      implementation: './middleware/auth.ts',
      priority: 10
    }
  ]
}

// In another plugin's manifest
capabilities: {
  extensions: [
    {
      targetPluginId: 'com.objectstack.server.hono',
      extensionPointId: 'com.objectstack.server.hono.extension.route',
      implementation: './routes/webhooks.ts',
      priority: 50
    }
  ]
}

// 404 Not Found
GET /api/v1/data/user/999
→ { "error": "Record not found" }

// 400 Bad Request
POST /api/v1/data/user (invalid data)
→ { "error": "Validation failed: email is required" }

// Cloudflare Workers, Vercel Edge, etc.
export default {
  async fetch(request: Request) {
    const app = createHonoApp();
    return app.fetch(request);
  }
}