noxious_server/src/utilities/http.ts

import { Application, Request, Response } from 'express'
import UserService from '../services/userService'
import jwt from 'jsonwebtoken'
import config from './config'
import { loginAccountSchema, registerAccountSchema } from './zodTypes'
import path from 'path'
import { TAsset } from './types'
import tileRepository from '../repositories/tileRepository'
import objectRepository from '../repositories/objectRepository'
import spriteRepository from '../repositories/spriteRepository'
import fs from 'fs'
import logger from './logger'
import zoneRepository from '../repositories/zoneRepository'
import zoneManager from '../managers/zoneManager'

async function addHttpRoutes(app: Application) {
  /**
   * Get all base sprite,  assets
   * @param req
   * @param res
   */
  app.get('/assets/sprites', async (req: Request, res: Response) => {
    let assets: TAsset[] = []

    const sprites = await spriteRepository.getAll()
    // sprites all contain spriteActions, loop through these
    sprites.forEach((sprite) => {
      sprite.spriteActions.forEach((spriteAction) => {
        assets.push({
          key: sprite.id + '-' + spriteAction.action,
          url: '/assets/sprites/' + sprite.id + '/' + spriteAction.action + '.png',
          group: spriteAction.isAnimated ? 'sprite_animations' : 'sprites',
          frameWidth: spriteAction.frameWidth,
          frameHeight: spriteAction.frameHeight
        })
      })
    })

    res.json(assets)
  })

  /**
   * Get assets for a specific zone
   * @param req
   * @param res
   */
  app.get('/assets/zone/:zoneId', async (req: Request, res: Response) => {
    const zoneId = req.params.zoneId
    if(!zoneId || parseInt(zoneId) === 0) {
      return res.status(400).json({ message: 'Invalid zone ID' })
    }

    const zone = await zoneRepository.getById(parseInt(zoneId))
    if(!zone) {
      return res.status(404).json({ message: 'Zone not found' })
    }

    const assets = await zoneManager.getZoneAssets(zone);

    res.json([
      ...assets.tiles.map(x => { return {
        key: x,
        url: '/assets/tiles/' + x + '.png',
        group: 'tiles'
      }}),
      ...assets.objects.map(x => { return {
        key: x,
        url: '/assets/objects/' + x + '.png',
        group: 'objects'
      }})
    ]);
  })

  /**
   * Get a specific asset
   * @param req
   * @param res
   */
  app.get('/assets/:type/:spriteId?/:file', (req: Request, res: Response) => {
    const assetType = req.params.type
    const spriteId = req.params.spriteId
    const fileName = req.params.file

    let assetPath
    if (assetType === 'sprites' && spriteId) {
      assetPath = path.join(process.cwd(), 'public', assetType, spriteId, fileName)
    } else {
      assetPath = path.join(process.cwd(), 'public', assetType, fileName)
    }

    if (!fs.existsSync(assetPath)) {
      logger.error(`File not found: ${assetPath}`)
      return res.status(404).send('Asset not found')
    }

    res.sendFile(assetPath, (err) => {
      if (err) {
        logger.error('Error sending file:', err)
        res.status(500).send('Error downloading the asset')
      }
    })
  })

  /**
   * Login
   * @param req
   * @param res
   */
  app.post('/login', async (req: Request, res: Response) => {
    const { username, password } = req.body

    try {
      loginAccountSchema.parse({ username, password })
    } catch (error: any) {
      return res.status(400).json({ message: error.errors[0]?.message })
    }

    const userService = new UserService()
    const user = await userService.login(username, password)

    if (user && typeof user !== 'boolean') {
      const token = jwt.sign({ id: user.id }, config.JWT_SECRET, { expiresIn: '4h' })
      return res.status(200).json({ token })
    }

    return res.status(400).json({ message: 'Failed to login' })
  })

  /**
   * Register
   * @param req
   * @param res
   */
  app.post('/register', async (req: Request, res: Response) => {
    const { username, password } = req.body

    try {
      registerAccountSchema.parse({ username, password })
    } catch (error: any) {
      return res.status(400).json({ message: error.errors[0]?.message })
    }

    const userService = new UserService()
    const user = await userService.register(username, password)

    if (user) {
      return res.status(200).json({ message: 'User registered' })
    }

    return res.status(400).json({ message: 'Failed to register user' })
  })

  logger.info('Web routes added')
}

export { addHttpRoutes }