src/controllers/imageController.js

//
// SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
// SPDX-License-Identifier: Apache-2.0
//

import config from '../../config.js';
import { generateId } from '../utils/idGenerator.js';
import { 
  validateGenerationParams, 
  validateApiConfig,
  validateImageIndex 
} from '../utils/validators.js';
import { 
  getStorage, 
  setStorage, 
  getDefaultData 
} from '../services/storageManager.js';
import { 
  generateImage, 
  cancelGeneration 
} from '../services/imageGenerator.js';
import { renderView } from '../utils/viewRenderer.js';
import { 
  sendToSession 
} from '../services/websocketManager.js';

export const renderHome = (req, res) => {
  const sessionId = generateId();
  const data = getDefaultData();
  
  renderView(res, {
    ...data,
    sessionId
  });
};

export const handleAction = async (req, res) => {
  const sessionId = req.body.sessionId || generateId();
  const { 
    action, 
    prompt, 
    model, 
    size, 
    imageIndex 
  } = req.body;
  
  let data = getStorage(sessionId) || getDefaultData();
  
  switch(action) {
    case 'delete':
      return handleDelete(
        sessionId, 
        imageIndex, 
        data, 
        res
      );
      
    case 'cancel':
      return handleCancel(sessionId, res);
      
    case 'generate':
      return handleGenerate(
        sessionId, 
        prompt, 
        model, 
        size, 
        data, 
        res
      );
      
    default:
      return res.json({ 
        success: false, 
        error: 'Invalid action' 
      });
  }
};

const handleDelete = (
  sessionId, 
  imageIndex, 
  data, 
  res
) => {
  if (validateImageIndex(
    imageIndex, 
    data.images.length
  )) {
    data.images.splice(parseInt(imageIndex), 1);
    setStorage(sessionId, data);
    
    sendToSession(sessionId, {
      type: 'imageDeleted',
      images: data.images
    });
  }
  
  return res.json({ 
    success: true, 
    images: data.images 
  });
};

const handleCancel = (sessionId, res) => {
  cancelGeneration(sessionId);
  
  sendToSession(sessionId, {
    type: 'generationCancelled'
  });
  
  return res.json({ 
    success: true 
  });
};

const handleGenerate = async (
  sessionId, 
  prompt, 
  model, 
  size, 
  data, 
  res
) => {
  const trimmedPrompt = prompt?.trim() || '';
  
  if (!validateGenerationParams(
    trimmedPrompt, 
    model, 
    size
  )) {
    return res.json({ 
      success: false, 
      error: 'Please fill in all required fields' 
    });
  }
  
  if (!validateApiConfig()) {
    return res.json({ 
      success: false, 
      error: 'API configuration missing'
    });
  }
  
  data.isGenerating = true;
  data.progress = 0;
  data.error = null;
  setStorage(sessionId, data);
  
  sendToSession(sessionId, {
    type: 'generationStarted',
    progress: 0
  });
  
  res.json({ 
    success: true, 
    sessionId 
  });
  
  await generateImage(
    sessionId, 
    trimmedPrompt, 
    model, 
    size
  );
};