Shatteredvoid/src/controllers/player/resource.controller.js

/**
 * Resource Controller
 * Handles resource-related API endpoints for players
 */

const ResourceService = require('../../services/resource/ResourceService');
const { asyncHandler } = require('../../middleware/error.middleware');
const logger = require('../../utils/logger');
const serviceLocator = require('../../services/ServiceLocator');

// Create resource service with WebSocket integration
function getResourceService() {
  const gameEventService = serviceLocator.get('gameEventService');
  return new ResourceService(gameEventService);
}

/**
 * Get player's current resources
 * GET /api/player/resources
 */
const getPlayerResources = asyncHandler(async (req, res) => {
  const correlationId = req.correlationId;
  const playerId = req.user.playerId;

  logger.info('Player resources request received', {
    correlationId,
    playerId,
  });

  const resourceService = getResourceService();
  const resources = await resourceService.getPlayerResources(playerId, correlationId);

  logger.info('Player resources retrieved', {
    correlationId,
    playerId,
    resourceCount: resources.length,
  });

  res.status(200).json({
    success: true,
    message: 'Resources retrieved successfully',
    data: {
      resources,
    },
    correlationId,
  });
});

/**
 * Get player's resource summary (simplified view)
 * GET /api/player/resources/summary
 */
const getPlayerResourceSummary = asyncHandler(async (req, res) => {
  const correlationId = req.correlationId;
  const playerId = req.user.playerId;

  logger.info('Player resource summary request received', {
    correlationId,
    playerId,
  });

  const resourceService = getResourceService();
  const summary = await resourceService.getPlayerResourceSummary(playerId, correlationId);

  logger.info('Player resource summary retrieved', {
    correlationId,
    playerId,
    resourceTypes: Object.keys(summary),
  });

  res.status(200).json({
    success: true,
    message: 'Resource summary retrieved successfully',
    data: {
      resources: summary,
    },
    correlationId,
  });
});

/**
 * Get player's resource production rates
 * GET /api/player/resources/production
 */
const getResourceProduction = asyncHandler(async (req, res) => {
  const correlationId = req.correlationId;
  const playerId = req.user.playerId;

  logger.info('Resource production request received', {
    correlationId,
    playerId,
  });

  const resourceService = getResourceService();
  const production = await resourceService.calculatePlayerResourceProduction(playerId, correlationId);

  logger.info('Resource production calculated', {
    correlationId,
    playerId,
    productionData: production,
  });

  res.status(200).json({
    success: true,
    message: 'Resource production retrieved successfully',
    data: {
      production,
    },
    correlationId,
  });
});

/**
 * Add resources to player (for testing/admin purposes)
 * POST /api/player/resources/add
 */
const addResources = asyncHandler(async (req, res) => {
  const correlationId = req.correlationId;
  const playerId = req.user.playerId;
  const { resources } = req.body;

  // Only allow in development environment
  if (process.env.NODE_ENV !== 'development') {
    logger.warn('Resource addition attempted in production', {
      correlationId,
      playerId,
    });

    return res.status(403).json({
      success: false,
      message: 'Resource addition not allowed in production',
      correlationId,
    });
  }

  logger.info('Resource addition request received', {
    correlationId,
    playerId,
    resources,
  });

  const resourceService = getResourceService();
  const updatedResources = await resourceService.addPlayerResources(
    playerId,
    resources,
    correlationId,
  );

  logger.info('Resources added successfully', {
    correlationId,
    playerId,
    updatedResources,
  });

  res.status(200).json({
    success: true,
    message: 'Resources added successfully',
    data: {
      updatedResources,
    },
    correlationId,
  });
});

/**
 * Transfer resources between colonies
 * POST /api/player/resources/transfer
 */
const transferResources = asyncHandler(async (req, res) => {
  const correlationId = req.correlationId;
  const playerId = req.user.playerId;
  const { fromColonyId, toColonyId, resources } = req.body;

  logger.info('Resource transfer request received', {
    correlationId,
    playerId,
    fromColonyId,
    toColonyId,
    resources,
  });

  const resourceService = getResourceService();
  const result = await resourceService.transferResourcesBetweenColonies(
    fromColonyId,
    toColonyId,
    resources,
    playerId,
    correlationId,
  );

  logger.info('Resources transferred successfully', {
    correlationId,
    playerId,
    fromColonyId,
    toColonyId,
    transferResult: result,
  });

  res.status(200).json({
    success: true,
    message: 'Resources transferred successfully',
    data: result,
    correlationId,
  });
});

/**
 * Get all available resource types
 * GET /api/player/resources/types
 */
const getResourceTypes = asyncHandler(async (req, res) => {
  const correlationId = req.correlationId;

  logger.info('Resource types request received', {
    correlationId,
  });

  const resourceService = getResourceService();
  const resourceTypes = await resourceService.getResourceTypes(correlationId);

  logger.info('Resource types retrieved', {
    correlationId,
    count: resourceTypes.length,
  });

  res.status(200).json({
    success: true,
    message: 'Resource types retrieved successfully',
    data: {
      resourceTypes,
    },
    correlationId,
  });
});

module.exports = {
  getPlayerResources,
  getPlayerResourceSummary,
  getResourceProduction,
  addResources,
  transferResources,
  getResourceTypes,
};