bowling-analysis-system/src/processors/OutputGeneratorProcessor.js

A comprehensive system for analyzing bowling techniques using video processing and metrics calculation

/**
 * Output Generator Processor
 * 
 * Generates formatted output from analysis results
 * @module processors/OutputGeneratorProcessor
 */

const { BaseProcessor } = require('../core/BaseProcessor');

/**
 * @class OutputGeneratorProcessor
 * @description Processor for generating formatted output from analysis results
 * @extends BaseProcessor
 */
class OutputGeneratorProcessor extends BaseProcessor {
  /**
   * Create a new output generator processor
   * @param {Object} config - Processor configuration
   */
  constructor(config = {}) {
    super('outputGenerator', config);
    this.formatters = new Map();
    
    // Register default formatters
    this.registerFormatter('json', this._formatJson.bind(this));
    this.registerFormatter('summary', this._formatSummary.bind(this));
  }

  /**
   * Register an output formatter
   * @param {string} format - Format name
   * @param {Function} formatter - Formatter function
   * @returns {OutputGeneratorProcessor} Processor instance for chaining
   */
  registerFormatter(format, formatter) {
    this.formatters.set(format, formatter);
    return this;
  }

  /**
   * Process input by generating formatted output
   * @param {Object} input - Input analysis results
   * @param {Object} context - Processing context
   * @returns {Promise<*>} Formatted output
   * @protected
   */
  async _process(input, context) {
    const format = this.config.format || 'json';
    const prettyPrint = this.config.prettyPrint !== false;
    
    // Get formatter
    const formatter = this.formatters.get(format);
    
    if (!formatter) {
      throw new Error(`Unknown output format: ${format}`);
    }
    
    // Apply formatter
    return formatter(input, { prettyPrint, ...context });
  }

  /**
   * Format output as JSON
   * @param {Object} input - Input data
   * @param {Object} options - Formatting options
   * @returns {string|Object} Formatted JSON
   * @private
   */
  _formatJson(input, options) {
    const { prettyPrint } = options;
    
    if (prettyPrint) {
      return JSON.stringify(input, null, 2);
    }
    
    return input;
  }

  /**
   * Format output as summary
   * @param {Object} input - Input data
   * @param {Object} options - Formatting options
   * @returns {Object} Summary object
   * @private
   */
  _formatSummary(input, options) {
    // Extract key information for summary
    const summary = {
      timestamp: Date.now(),
      metrics: {
        count: Object.keys(input.metrics || {}).length
      },
      events: {
        count: (input.events && input.events.events) ? input.events.events.length : 0
      },
      analysis: {
        insights: (input.analysis && input.analysis.insights) ? input.analysis.insights.length : 0,
        recommendations: (input.analysis && input.analysis.recommendations) ? input.analysis.recommendations.length : 0
      }
    };
    
    // Add top recommendations if available
    if (input.analysis && input.analysis.recommendations && input.analysis.recommendations.length > 0) {
      summary.topRecommendations = input.analysis.recommendations
        .sort((a, b) => a.priority - b.priority)
        .slice(0, 3)
        .map(rec => rec.recommendation);
    }
    
    return summary;
  }
}

module.exports = OutputGeneratorProcessor;