package ocelot.desktop

import java.io.{PrintWriter, StringWriter}

import ocelot.desktop.ui.UiHandler
import ocelot.desktop.ui.widget.ScreenWidget
import ocelot.desktop.util.{Audio, ResourceManager}
import org.apache.logging.log4j.LogManager
import org.apache.logging.log4j.scala.Logging
import org.lwjgl.Version
import totoro.ocelot.brain.Ocelot
import totoro.ocelot.brain.entity.{APU, Cable, Case, Keyboard, Memory, Screen}
import totoro.ocelot.brain.event._
import totoro.ocelot.brain.loot.Loot
import totoro.ocelot.brain.network.Network
import totoro.ocelot.brain.util.Tier


object OcelotDesktop extends Logging {
  var screenWidget: ScreenWidget = _
  var ui: UiHandler = _

  def mainInner(): Unit = {
    logger.info("Starting up Ocelot Desktop")
    logger.info(s"Using LWJGL ${Version.getVersion}")

    Ocelot.initialize(LogManager.getLogger(Ocelot))
    createWorkspace()

    screenWidget = new ScreenWidget(screen)
    ui = new UiHandler(screenWidget)

    setupEventHandlers()
    computer.turnOn()

    new Thread(() => {
      while (true) {
        computer.update()
        Thread.sleep(50)
      }
    }).start()

    ui.init()
    ui.start()

    logger.info("Cleaning up")

    ResourceManager.freeResources()
    ui.terminate()

    logger.info("Thanks for using Ocelot Desktop")
    System.exit(0)
  }

  def main(args: Array[String]): Unit = {
    try mainInner()
    catch {
      case e: Exception =>
        val sw = new StringWriter
        val pw = new PrintWriter(sw)

        e.printStackTrace(pw)

        logger.error(s"${sw.toString}")
    }
  }

  var computer: Case = _
  var screen: Screen = _

  private def createWorkspace(): Unit = {
    val network = new Network()

    val cable = new Cable()

    network.connect(cable)

    computer = new Case(Tier.Four)

    cable.connect(computer)

    val cpu = new APU(Tier.Two)
    computer.add(cpu)

    val memory = new Memory(Tier.Six)
    computer.add(memory)

    computer.add(Loot.AdvLoaderEEPROM.create())
    computer.add(Loot.OpenOsFloppy.create())

    screen = new Screen(Tier.Three)
    cable.connect(screen)

    val keyboard = new Keyboard
    screen.connect(keyboard)
  }

  private def setupEventHandlers(): Unit = {
    EventBus.listenTo(classOf[BeepEvent], { case event: BeepEvent =>
      Audio.beep(event.frequency, event.duration)
    })

    EventBus.listenTo(classOf[BeepPatternEvent], { case event: BeepPatternEvent =>
      logger.info(s"[EVENT] Beep (address = ${event.address}, pattern = ${event.pattern})")
    })

    EventBus.listenTo(classOf[MachineCrashEvent], { case event: MachineCrashEvent =>
      logger.info(s"[EVENT] Machine crash! (address = ${event.address}, ${event.message})")
    })

    EventBus.listenTo(classOf[TextBufferSetEvent], { case event: TextBufferSetEvent =>
      screenWidget.set(event.x, event.y, event.value, event.vertical)
    })

    EventBus.listenTo(classOf[TextBufferFillEvent], { case event: TextBufferFillEvent =>
      screenWidget.fill(event.x, event.y, event.width, event.height, event.value)
    })

    EventBus.listenTo(classOf[TextBufferCopyEvent], { case event: TextBufferCopyEvent =>
      screenWidget.copy(event.x, event.y, event.width, event.height, event.horizontalTranslation, event.verticalTranslation)
    })

    EventBus.listenTo(classOf[TextBufferSetForegroundColorEvent], { case event: TextBufferSetForegroundColorEvent =>
      screenWidget.foreground = event.color
    })

    EventBus.listenTo(classOf[TextBufferSetBackgroundColorEvent], { case event: TextBufferSetBackgroundColorEvent =>
      screenWidget.background = event.color
    })
  }
}