// Copyright (c) 2023 Dominic Masters
// 
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT

#include "VNSceneGen.hpp"

using namespace Dawn;

void VNSceneGen::test(
  std::string eventName,
  struct VNSceneEvent *event,
  int32_t *eventIndex,
  std::vector<std::string> *body,
  std::vector<std::string> *includes
) {
  std::string initType = "";
  std::string toInclude = "";
  std::string initArgs = "";
  std::vector<std::string> afterLines;

  switch(event->type) {
    case VN_SCENE_EVENT_TYPE_TEXT:
      initType = "VNTextEvent";
      toInclude = "games/vn/events/VNTextEvent.hpp";
      line(&afterLines, eventName + "->" + "text = \"" + event->text.texts.begin()->text + "\";", "");
      break;

    case VN_SCENE_EVENT_TYPE_POSITION:
      initType = "VNPositionEvent";
      toInclude = "games/vn/events/VNPositionEvent.hpp";
      line(&afterLines, eventName + "->item = " + event->position.item + ";", "");
      if(event->position.x != "") line(&afterLines, eventName + "->" + "to.x = " + event->position.x + ";", "");
      if(event->position.y != "") line(&afterLines, eventName + "->" + "to.y = " + event->position.y + ";", "");
      if(event->position.z != "") line(&afterLines, eventName + "->" + "to.z = " + event->position.z + ";", "");
      break;

    case VN_SCENE_EVENT_TYPE_SET:
      initType = "VNSetEvent<" + event->set.type + ">";
      toInclude = "games/vn/events/VNSetEvent.hpp";
      line(&afterLines, eventName + "->modifies = &" + event->set.property + ";", "");
      line(&afterLines, eventName + "->to = " + event->set.to + ";", "");
      if(event->set.from != "") line(&afterLines, eventName + "->from = " + event->set.from + ";", "");
      if(event->set.duration != "") line(&afterLines, eventName + "->duration = " + event->set.duration + ";", "");
      break;

    case VN_SCENE_EVENT_TYPE_WAIT:
      initType = "VNWaitEvent";
      toInclude = "games/vn/events/VNWaitEvent.hpp";
      line(&afterLines, eventName + "->duration = " + event->wait.duration + ";", "");
      break;

    case VN_SCENE_EVENT_TYPE_PARALLEL: {
      initType = "VNParallelEvent";
      toInclude = "games/vn/events/VNParallelEvent.hpp";

      auto itParallel = event->parallel.events.events.begin();
      while(itParallel != event->parallel.events.events.end()) {
        std::string pEventName = "pEvent" + std::to_string((*eventIndex)++);
        VNSceneGen::test(
          pEventName,
          &(*itParallel),
          eventIndex,
          &afterLines,
          includes
        );
        line(&afterLines, eventName + "->events.push_back(" + pEventName + ");", "");
        line(&afterLines, "", "");
        ++itParallel;
      }
      break;
    }

    case VN_SCENE_EVENT_TYPE_MARKER:
      initType = "VNDummyEvent";
      toInclude = "games/vn/events/VNDummyEvent.hpp";
      line(&afterLines, "auto marker_" + event->marker.name + " = " + eventName + ";", "");
      break;

    case VN_SCENE_EVENT_TYPE_GOTO_MARKER:
      initType = "VNDummyEvent";
      toInclude = "games/vn/events/VNDummyEvent.hpp";
      line(&afterLines, eventName + "->then(marker_" + event->gotoMarker.name + ");", "");
      break;

    case VN_SCENE_EVENT_TYPE_CHOICES: {
      initType = "VNChoiceEvent";
      toInclude = "games/vn/events/VNChoiceEvent.hpp";
      line(&afterLines, eventName + "->key = \"" + event->choices.key+ "\";", "");
      line(&afterLines, eventName + "->text = \"" + event->choices.titles.begin()->text + "\";", "");
      auto itChoices = event->choices.choices.begin();
      while(itChoices != event->choices.choices.end()) {
        line(&afterLines, eventName + "->choices[\"" + itChoices->value + "\"] = \"" + itChoices->texts.begin()->text + "\";", "");
        ++itChoices;
      }
      break;
    }

    case VN_SCENE_EVENT_TYPE_CHOICE_SET:
      initType = "VNChoiceSetEvent";
      toInclude = "games/vn/events/VNChoiceSetEvent.hpp";
      line(&afterLines, eventName + "->key = \"" + event->choiceSet.key + "\";", "");
      line(&afterLines, eventName + "->value = \"" + event->choiceSet.value + "\";", "");
      break;

    case VN_SCENE_EVENT_TYPE_IF: {
      initType = "VNIfEvent";
      toInclude = "games/vn/events/VNIfEvent.hpp";
      line(&afterLines, eventName + "->key = \"" + event->ifEvent.key + "\";", "");
      line(&afterLines, eventName + "->value = \"" + event->ifEvent.value + "\";", "");

      std::string ifPrevious = "";
      std::string ifFirst = "";
      auto itIf = event->ifEvent.events.events.begin();
      while(itIf != event->ifEvent.events.events.end()) {
        std::string ifEventName = "ifEvent" + std::to_string((*eventIndex)++);
        VNSceneGen::test(
          ifEventName,
          &(*itIf),
          eventIndex,
          &afterLines,
          includes
        );
        if(!ifPrevious.empty()) line(&afterLines, ifPrevious + "->then(" + ifEventName + ");", "");
        ifPrevious = ifEventName;
        if(ifFirst == "") ifFirst = ifEventName;
        ++itIf;
      }

      if(ifFirst == "" || ifPrevious == "") {
        std::cout << "If event must have at least one event" << std::endl;
        assertUnreachable();
      }

      line(&afterLines, eventName + "->ifTrue = " + ifFirst + ";", "");
      line(&afterLines, eventName + "->ifEnd = " + ifPrevious + ";", "");
      break;
    }

    default:
      std::cout << "Unknown event type: " << event->type << std::endl;
      assertUnreachable();
  }

  if(!toInclude.empty()) includes->push_back(toInclude);

  line(body, "auto " + eventName + " = vnManager->createEvent<" + initType + ">(" + initArgs + ");", "");
  lines(body, afterLines, "");
}

void VNSceneGen::generate(
  std::vector<std::string> *out,
  struct VNScene *scene,
  std::string tabs
) {
  struct ClassGenInfo classInfo;
  struct MethodGenInfo methodAssets;
  struct MethodGenInfo methodInit;


  // Load Scene
  SceneGenerator::generate(
    &scene->scene,
    classInfo,
    methodAssets,
    methodInit
  );


  // Events
  classInfo.includes.push_back("games/vn/components/VNManager.hpp");
  line(&methodInit.body, "auto vnItem = this->createSceneItem();", "");
  line(&methodInit.body, "auto vnManager = vnItem->addComponent<VNManager>();", "");
  line(&methodInit.body, "VNEvent *previous = vnManager->createEvent<VNDummyEvent>();", "");
  line(&methodInit.body, "auto eventStart = previous;", "");

  int32_t eventIndex = 0;
  auto itEvents = scene->events.events.begin();
  std::string previous = "eventStart";
  while(itEvents != scene->events.events.end()) {
    line(&methodInit.body, "", "");
    std::string eventName = "event" + std::to_string(eventIndex++);
    VNSceneGen::test(
      eventName,
      &(*itEvents),
      &eventIndex,
      &methodInit.body,
      &classInfo.includes
    );
    line(&methodInit.body, previous + "->then(" + eventName + ");", "");
    previous = eventName;
    ++itEvents;
  }
  line(&methodInit.body, "", "");
  line(&methodInit.body, "vnManager->setEvent(eventStart);", "");


  // Add in methods
  CodeGen::methodGen(&classInfo.publicCode, methodAssets);
  line(&classInfo.publicCode, "", "");
  CodeGen::methodGen(&classInfo.publicCode, methodInit);

  CodeGen::classGen(out, classInfo);
}