stock-bot/apps/data-services/feature-store/src/controllers/ComputationController.ts

import { Context } from 'hono';
import { FeatureComputationService } from '../services/FeatureComputationService';
import { Logger } from '@stock-bot/utils';
import { 
  ComputationJob, 
  CreateComputationJobRequest,
  UpdateComputationJobRequest 
} from '../types/FeatureStore';

export class ComputationController {
  constructor(
    private computationService: FeatureComputationService,
    private logger: Logger
  ) {}

  async createComputationJob(c: Context) {
    try {
      const request: CreateComputationJobRequest = await c.req.json();
      
      const job = await this.computationService.createComputationJob(request);
      
      this.logger.info('Computation job created', { jobId: job.id });
      
      return c.json({ 
        success: true, 
        data: job 
      }, 201);
    } catch (error) {
      this.logger.error('Failed to create computation job', { error });
      return c.json({ 
        success: false, 
        error: error instanceof Error ? error.message : 'Unknown error' 
      }, 500);
    }
  }

  async getComputationJob(c: Context) {
    try {
      const jobId = c.req.param('id');
      
      const job = await this.computationService.getComputationJob(jobId);
      
      if (!job) {
        return c.json({ 
          success: false, 
          error: 'Computation job not found' 
        }, 404);
      }
      
      return c.json({ 
        success: true, 
        data: job 
      });
    } catch (error) {
      this.logger.error('Failed to get computation job', { error });
      return c.json({ 
        success: false, 
        error: error instanceof Error ? error.message : 'Unknown error' 
      }, 500);
    }
  }

  async updateComputationJob(c: Context) {
    try {
      const jobId = c.req.param('id');
      const request: UpdateComputationJobRequest = await c.req.json();
      
      const job = await this.computationService.updateComputationJob(jobId, request);
      
      if (!job) {
        return c.json({ 
          success: false, 
          error: 'Computation job not found' 
        }, 404);
      }
      
      this.logger.info('Computation job updated', { jobId });
      
      return c.json({ 
        success: true, 
        data: job 
      });
    } catch (error) {
      this.logger.error('Failed to update computation job', { error });
      return c.json({ 
        success: false, 
        error: error instanceof Error ? error.message : 'Unknown error' 
      }, 500);
    }
  }

  async deleteComputationJob(c: Context) {
    try {
      const jobId = c.req.param('id');
      
      await this.computationService.deleteComputationJob(jobId);
      
      this.logger.info('Computation job deleted', { jobId });
      
      return c.json({ 
        success: true, 
        message: 'Computation job deleted successfully' 
      });
    } catch (error) {
      this.logger.error('Failed to delete computation job', { error });
      return c.json({ 
        success: false, 
        error: error instanceof Error ? error.message : 'Unknown error' 
      }, 500);
    }
  }

  async listComputationJobs(c: Context) {
    try {
      const featureGroupId = c.req.query('featureGroupId');
      const status = c.req.query('status');
      
      const jobs = await this.computationService.listComputationJobs({
        featureGroupId,
        status: status as any
      });
      
      return c.json({ 
        success: true, 
        data: jobs 
      });
    } catch (error) {
      this.logger.error('Failed to list computation jobs', { error });
      return c.json({ 
        success: false, 
        error: error instanceof Error ? error.message : 'Unknown error' 
      }, 500);
    }
  }

  async executeComputationJob(c: Context) {
    try {
      const jobId = c.req.param('id');
      
      const result = await this.computationService.executeComputationJob(jobId);
      
      this.logger.info('Computation job executed', { jobId, result });
      
      return c.json({ 
        success: true, 
        data: result 
      });
    } catch (error) {
      this.logger.error('Failed to execute computation job', { error });
      return c.json({ 
        success: false, 
        error: error instanceof Error ? error.message : 'Unknown error' 
      }, 500);
    }
  }

  async scheduleComputationJob(c: Context) {
    try {
      const jobId = c.req.param('id');
      const { schedule } = await c.req.json();
      
      await this.computationService.scheduleComputationJob(jobId, schedule);
      
      this.logger.info('Computation job scheduled', { jobId, schedule });
      
      return c.json({ 
        success: true, 
        message: 'Computation job scheduled successfully' 
      });
    } catch (error) {
      this.logger.error('Failed to schedule computation job', { error });
      return c.json({ 
        success: false, 
        error: error instanceof Error ? error.message : 'Unknown error' 
      }, 500);
    }
  }

  async unscheduleComputationJob(c: Context) {
    try {
      const jobId = c.req.param('id');
      
      await this.computationService.unscheduleComputationJob(jobId);
      
      this.logger.info('Computation job unscheduled', { jobId });
      
      return c.json({ 
        success: true, 
        message: 'Computation job unscheduled successfully' 
      });
    } catch (error) {
      this.logger.error('Failed to unschedule computation job', { error });
      return c.json({ 
        success: false, 
        error: error instanceof Error ? error.message : 'Unknown error' 
      }, 500);
    }
  }

  async getComputationJobHistory(c: Context) {
    try {
      const jobId = c.req.param('id');
      const limit = parseInt(c.req.query('limit') || '10');
      const offset = parseInt(c.req.query('offset') || '0');
      
      const history = await this.computationService.getComputationJobHistory(jobId, limit, offset);
      
      return c.json({ 
        success: true, 
        data: history 
      });
    } catch (error) {
      this.logger.error('Failed to get computation job history', { error });
      return c.json({ 
        success: false, 
        error: error instanceof Error ? error.message : 'Unknown error' 
      }, 500);
    }
  }
}