// This file is part of the 64k demo project.
// It implements the sequence compiler tool.
// Converts a text-based timeline description into C++ code.

#include <algorithm>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>

struct EffectEntry {
  std::string class_name;
  std::string start;
  std::string end;
  std::string priority;
  std::string extra_args;
};

struct SequenceEntry {
  std::string start_time;
  std::string priority;
  std::string end_time;  // Optional: -1.0f means "no explicit end"
  std::vector<EffectEntry> effects;
};

std::string trim(const std::string& str) {
  size_t first = str.find_first_not_of(" \t");
  if (std::string::npos == first)
    return "";  // String is all whitespace, return empty string
  size_t last = str.find_last_not_of(" \t");
  return str.substr(first, (last - first + 1));
}

// Generate ASCII Gantt chart for timeline visualization
void generate_gantt_chart(const std::string& output_file,
                          const std::vector<SequenceEntry>& sequences,
                          float bpm, const std::string& demo_end_time) {
  std::ofstream out(output_file);
  if (!out.is_open()) {
    std::cerr << "Warning: Could not open Gantt chart output file: " << output_file << "\n";
    return;
  }

  // Find max time for the chart
  float max_time = demo_end_time.empty() ? 0.0f : std::stof(demo_end_time);
  for (const auto& seq : sequences) {
    float seq_start = std::stof(seq.start_time);
    for (const auto& eff : seq.effects) {
      float eff_end = seq_start + std::stof(eff.end);
      max_time = std::max(max_time, eff_end);
    }
    if (seq.end_time != "-1.0") {
      max_time = std::max(max_time, seq_start + std::stof(seq.end_time));
    }
  }

  // Chart configuration
  const int chart_width = 100;
  const float time_scale = chart_width / max_time;

  out << "Demo Timeline Gantt Chart\n";
  out << "==============================================================================\n";
  out << "BPM: " << bpm << ", Duration: " << max_time << "s";
  if (!demo_end_time.empty()) {
    out << " (explicit end)";
  }
  out << "\n\n";

  // Time axis header
  out << "Time (s): ";
  for (int i = 0; i <= (int)max_time; i += 5) {
    out << i;
    int spacing = (i < 10) ? 4 : (i < 100) ? 3 : 2;
    if (i + 5 <= max_time) {
      for (int j = 0; j < spacing; ++j) out << " ";
    }
  }
  out << "\n";
  out << "          ";
  for (int i = 0; i < chart_width; ++i) {
    if (i % 5 == 0) out << "|";
    else out << "-";
  }
  out << "\n\n";

  // Draw sequences and effects
  for (const auto& seq : sequences) {
    float seq_start = std::stof(seq.start_time);
    float seq_end = seq_start;  // Start at sequence start

    // Check if sequence has explicit end time
    if (seq.end_time != "-1.0") {
      seq_end = seq_start + std::stof(seq.end_time);
    } else {
      // Calculate implicit end from latest effect
      for (const auto& eff : seq.effects) {
        seq_end = std::max(seq_end, seq_start + std::stof(eff.end));
      }
    }

    // Draw sequence bar
    out << "SEQ@" << seq_start << "s [pri=" << seq.priority << "]";
    if (seq.end_time != "-1.0") {
      out << " [END=" << seq_end << "s]";
    }
    out << "\n";

    int start_col = (int)(seq_start * time_scale);
    int end_col = (int)(seq_end * time_scale);
    out << "          ";
    for (int i = 0; i < chart_width; ++i) {
      if (i >= start_col && i < end_col) out << "█";
      else out << " ";
    }
    out << "  (" << seq_start << "-" << seq_end << "s)\n";

    // Draw effects within sequence
    for (const auto& eff : seq.effects) {
      float eff_start = seq_start + std::stof(eff.start);
      float eff_end = seq_start + std::stof(eff.end);

      // Truncate if sequence has explicit end time
      if (seq.end_time != "-1.0") {
        eff_end = std::min(eff_end, seq_end);
      }

      out << "  " << eff.class_name << " [pri=" << eff.priority << "]";
      if (eff_end < eff_start) {
        out << " *** INVALID TIME RANGE ***";
      }
      out << "\n";
      out << "          ";

      int eff_start_col = (int)(eff_start * time_scale);
      int eff_end_col = (int)(eff_end * time_scale);

      for (int i = 0; i < chart_width; ++i) {
        if (i >= eff_start_col && i < eff_end_col) {
          out << "▓";
        } else if (i >= start_col && i < end_col) {
          out << "·";  // Show sequence background
        } else {
          out << " ";
        }
      }
      out << "  (" << eff_start << "-" << eff_end << "s)\n";
    }
    out << "\n";
  }

  out << "==============================================================================\n";
  out << "Legend: █ Sequence  ▓ Effect  · Sequence background\n";
  out << "Priority: Higher numbers render later (on top)\n";

  out.close();
  std::cout << "Gantt chart written to: " << output_file << "\n";
}

// Generate HTML/SVG Gantt chart for timeline visualization
void generate_gantt_html(const std::string& output_file,
                         const std::vector<SequenceEntry>& sequences,
                         float bpm, const std::string& demo_end_time) {
  std::ofstream out(output_file);
  if (!out.is_open()) {
    std::cerr << "Warning: Could not open HTML Gantt output file: " << output_file << "\n";
    return;
  }

  // Find max time for the chart
  float max_time = demo_end_time.empty() ? 0.0f : std::stof(demo_end_time);
  for (const auto& seq : sequences) {
    float seq_start = std::stof(seq.start_time);
    for (const auto& eff : seq.effects) {
      float eff_end = seq_start + std::stof(eff.end);
      max_time = std::max(max_time, eff_end);
    }
    if (seq.end_time != "-1.0") {
      max_time = std::max(max_time, seq_start + std::stof(seq.end_time));
    }
  }

  const int svg_width = 1400;
  const int row_height = 30;
  const int effect_height = 20;
  const int margin_left = 250;
  const int margin_top = 60;
  const float time_scale = (svg_width - margin_left - 50) / max_time;

  // Count total rows needed
  int total_rows = 0;
  for (const auto& seq : sequences) {
    total_rows += 1 + seq.effects.size();  // 1 for sequence + N for effects
  }

  const int svg_height = margin_top + total_rows * row_height + 40;

  out << "<!DOCTYPE html>\n<html>\n<head>\n";
  out << "<meta charset=\"UTF-8\">\n";
  out << "<title>Demo Timeline - BPM " << bpm << "</title>\n";
  out << "<style>\n";
  out << "body { font-family: 'Courier New', monospace; margin: 20px; background: #1e1e1e; color: #d4d4d4; }\n";
  out << "h1 { color: #569cd6; }\n";
  out << ".info { background: #252526; padding: 10px; border-radius: 4px; margin: 10px 0; }\n";
  out << "svg { background: #252526; border-radius: 4px; }\n";
  out << ".sequence-bar { fill: #3a3a3a; stroke: #569cd6; stroke-width: 2; }\n";
  out << ".effect-bar { fill: #4ec9b0; opacity: 0.8; stroke: #2a7a6a; stroke-width: 1; }\n";
  out << ".effect-bar.invalid { fill: #f48771; stroke: #d16969; }\n";
  out << ".label { fill: #d4d4d4; font-size: 12px; }\n";
  out << ".label.effect { fill: #cccccc; font-size: 11px; }\n";
  out << ".axis-line { stroke: #6a6a6a; stroke-width: 1; }\n";
  out << ".axis-label { fill: #858585; font-size: 10px; }\n";
  out << ".time-marker { stroke: #444444; stroke-width: 1; stroke-dasharray: 2,2; }\n";
  out << "rect:hover { opacity: 1; }\n";
  out << "title { font-size: 11px; }\n";
  out << "</style>\n</head>\n<body>\n";

  out << "<h1>Demo Timeline Gantt Chart</h1>\n";
  out << "<div class=\"info\">\n";
  out << "<strong>BPM:</strong> " << bpm << " | ";
  out << "<strong>Duration:</strong> " << max_time << "s";
  if (!demo_end_time.empty()) {
    out << " (explicit end)";
  }
  out << " | <strong>Sequences:</strong> " << sequences.size() << "\n";
  out << "</div>\n\n";

  out << "<svg width=\"" << svg_width << "\" height=\"" << svg_height << "\" xmlns=\"http://www.w3.org/2000/svg\">\n";

  // Draw time axis
  out << "  <!-- Time axis -->\n";
  out << "  <line x1=\"" << margin_left << "\" y1=\"" << margin_top - 10
      << "\" x2=\"" << (svg_width - 50) << "\" y2=\"" << margin_top - 10
      << "\" class=\"axis-line\"/>\n";

  for (int t = 0; t <= (int)max_time; t += 5) {
    int x = margin_left + (int)(t * time_scale);
    out << "  <line x1=\"" << x << "\" y1=\"" << margin_top - 15
        << "\" x2=\"" << x << "\" y2=\"" << margin_top - 5
        << "\" class=\"axis-line\"/>\n";
    out << "  <text x=\"" << x << "\" y=\"" << margin_top - 20
        << "\" class=\"axis-label\" text-anchor=\"middle\">" << t << "s</text>\n";
    // Draw vertical time markers
    out << "  <line x1=\"" << x << "\" y1=\"" << margin_top
        << "\" x2=\"" << x << "\" y2=\"" << svg_height - 20
        << "\" class=\"time-marker\"/>\n";
  }

  // Draw sequences and effects
  int y_offset = margin_top;
  for (const auto& seq : sequences) {
    float seq_start = std::stof(seq.start_time);
    float seq_end = seq_start;  // Start at sequence start

    if (seq.end_time != "-1.0") {
      seq_end = seq_start + std::stof(seq.end_time);
    } else {
      for (const auto& eff : seq.effects) {
        seq_end = std::max(seq_end, seq_start + std::stof(eff.end));
      }
    }

    int x1 = margin_left + (int)(seq_start * time_scale);
    int x2 = margin_left + (int)(seq_end * time_scale);

    // Draw sequence bar
    out << "  <!-- Sequence -->\n";
    out << "  <rect x=\"" << x1 << "\" y=\"" << y_offset
        << "\" width=\"" << (x2 - x1) << "\" height=\"" << row_height
        << "\" class=\"sequence-bar\">\n";
    out << "    <title>SEQ@" << seq_start << "s [pri=" << seq.priority << "] ("
        << seq_start << "-" << seq_end << "s)</title>\n";
    out << "  </rect>\n";

    // Draw sequence label
    out << "  <text x=\"10\" y=\"" << (y_offset + row_height / 2 + 4)
        << "\" class=\"label\">SEQ@" << seq_start << "s [pri=" << seq.priority << "]</text>\n";

    y_offset += row_height;

    // Draw effects
    for (const auto& eff : seq.effects) {
      float eff_start = seq_start + std::stof(eff.start);
      float eff_end = seq_start + std::stof(eff.end);

      if (seq.end_time != "-1.0") {
        eff_end = std::min(eff_end, seq_end);
      }

      bool invalid = eff_end < eff_start;
      int eff_x1 = margin_left + (int)(eff_start * time_scale);
      int eff_x2 = margin_left + (int)(eff_end * time_scale);
      int eff_width = std::max(2, eff_x2 - eff_x1);

      out << "  <rect x=\"" << eff_x1 << "\" y=\"" << (y_offset + 5)
          << "\" width=\"" << eff_width << "\" height=\"" << effect_height
          << "\" class=\"effect-bar" << (invalid ? " invalid" : "") << "\">\n";
      out << "    <title>" << eff.class_name << " [pri=" << eff.priority << "] ("
          << eff_start << "-" << eff_end << "s)"
          << (invalid ? " *** INVALID TIME RANGE ***" : "") << "</title>\n";
      out << "  </rect>\n";

      out << "  <text x=\"20\" y=\"" << (y_offset + effect_height)
          << "\" class=\"label effect\">" << eff.class_name << " [pri=" << eff.priority << "]"
          << (invalid ? " ⚠" : "") << "</text>\n";

      y_offset += row_height;
    }
  }

  // Legend
  out << "  <!-- Legend -->\n";
  out << "  <rect x=\"10\" y=\"" << (svg_height - 15) << "\" width=\"20\" height=\"10\" class=\"sequence-bar\"/>\n";
  out << "  <text x=\"35\" y=\"" << (svg_height - 7) << "\" class=\"axis-label\">Sequence</text>\n";
  out << "  <rect x=\"120\" y=\"" << (svg_height - 15) << "\" width=\"20\" height=\"10\" class=\"effect-bar\"/>\n";
  out << "  <text x=\"145\" y=\"" << (svg_height - 7) << "\" class=\"axis-label\">Effect</text>\n";
  out << "  <rect x=\"220\" y=\"" << (svg_height - 15) << "\" width=\"20\" height=\"10\" class=\"effect-bar invalid\"/>\n";
  out << "  <text x=\"245\" y=\"" << (svg_height - 7) << "\" class=\"axis-label\">Invalid Time Range</text>\n";

  out << "</svg>\n";
  out << "<div class=\"info\">\n";
  out << "<strong>Tip:</strong> Hover over bars to see details. ";
  out << "Higher priority numbers render later (on top).\n";
  out << "</div>\n";
  out << "</body>\n</html>\n";

  out.close();
  std::cout << "HTML Gantt chart written to: " << output_file << "\n";
}

// Convert beat notation to time in seconds
// Supports: "64b" or "64" (beats), "32.0s" or "32.0" with decimal point (seconds)
std::string convert_to_time(const std::string& value, float bpm) {
  std::string val = value;
  bool is_beat = false;

  // Check for explicit 'b' suffix (beat)
  if (!val.empty() && val.back() == 'b') {
    is_beat = true;
    val.pop_back();
  }
  // Check for explicit 's' suffix (seconds)
  else if (!val.empty() && val.back() == 's') {
    val.pop_back();
    return val;  // Already in seconds
  }
  // If no suffix and no decimal point, assume beats
  else if (val.find('.') == std::string::npos) {
    is_beat = true;
  }

  if (is_beat) {
    float beat = std::stof(val);
    float time = beat * 60.0f / bpm;
    return std::to_string(time);
  }

  return val;  // Return as-is (seconds)
}

int main(int argc, char* argv[]) {
  if (argc < 2) {
    std::cerr << "Usage: " << argv[0] << " <input.seq> [output.cc] [--gantt=<file.txt>] [--gantt-html=<file.html>]\n";
    std::cerr << "Examples:\n";
    std::cerr << "  " << argv[0] << " assets/demo.seq src/generated/timeline.cc\n";
    std::cerr << "  " << argv[0] << " assets/demo.seq --gantt=timeline.txt\n";
    std::cerr << "  " << argv[0] << " assets/demo.seq --gantt-html=timeline.html\n";
    std::cerr << "  " << argv[0] << " assets/demo.seq timeline.cc --gantt=timeline.txt --gantt-html=timeline.html\n";
    std::cerr << "\nIf output.cc is omitted, only validation and Gantt generation are performed.\n";
    return 1;
  }

  std::string output_cc = "";
  std::string gantt_output = "";
  std::string gantt_html_output = "";

  // Parse command line arguments
  for (int i = 2; i < argc; ++i) {
    std::string arg = argv[i];
    if (arg.rfind("--gantt=", 0) == 0) {
      gantt_output = arg.substr(8);
    } else if (arg.rfind("--gantt-html=", 0) == 0) {
      gantt_html_output = arg.substr(13);
    } else if (output_cc.empty() && arg[0] != '-') {
      output_cc = arg;
    }
  }

  std::ifstream in_file(argv[1]);
  if (!in_file.is_open()) {
    std::cerr << "Error: Could not open input file " << argv[1] << "\n";
    return 1;
  }

  std::vector<SequenceEntry> sequences;
  SequenceEntry* current_seq = nullptr;
  float bpm = 120.0f;  // Default BPM
  std::string demo_end_time = "";  // Demo end time (optional)

  std::string line;
  int line_num = 0;
  while (std::getline(in_file, line)) {
    ++line_num;
    std::string trimmed = trim(line);
    if (trimmed.empty())
      continue;

    // Parse BPM from comment
    if (trimmed[0] == '#') {
      std::stringstream ss(trimmed);
      std::string hash, keyword;
      ss >> hash >> keyword;
      if (keyword == "BPM") {
        ss >> bpm;
        std::cout << "Using BPM: " << bpm << "\n";
      }
      continue;
    }

    std::stringstream ss(trimmed);
    std::string command;
    ss >> command;

    if (command == "END_DEMO") {
      std::string end_time;
      if (!(ss >> end_time)) {
        std::cerr << "Error line " << line_num
                  << ": END_DEMO requires <time>\n";
        return 1;
      }
      // Convert beat notation to time
      demo_end_time = convert_to_time(end_time, bpm);
      std::cout << "Demo end time: " << demo_end_time << "s\n";
    } else if (command == "SEQUENCE") {
      std::string start, priority;
      if (!(ss >> start >> priority)) {
        std::cerr << "Error line " << line_num
                  << ": SEQUENCE requires <start> <priority>\n";
        return 1;
      }
      // Convert beat notation to time
      std::string start_time = convert_to_time(start, bpm);

      // Check for optional [end_time]
      std::string end_time_str = "-1.0";  // Default: no explicit end
      std::string optional_param;
      if (ss >> optional_param) {
        // Check if it's wrapped in brackets [time]
        if (optional_param.size() >= 3 &&
            optional_param.front() == '[' &&
            optional_param.back() == ']') {
          // Extract time from [time]
          std::string time_value = optional_param.substr(1, optional_param.size() - 2);
          end_time_str = convert_to_time(time_value, bpm);
        } else {
          std::cerr << "Error line " << line_num
                    << ": Optional sequence end time must be in brackets [time]\n";
          return 1;
        }
      }

      sequences.push_back({start_time, priority, end_time_str, {}});
      current_seq = &sequences.back();
    } else if (command == "EFFECT") {
      if (!current_seq) {
        std::cerr << "Error line " << line_num
                  << ": EFFECT found outside of SEQUENCE\n";
        return 1;
      }
      std::string priority_mod, class_name, start, end;
      if (!(ss >> priority_mod >> class_name >> start >> end)) {
        std::cerr << "Error line " << line_num
                  << ": EFFECT requires <+|=|-> <Class> <start> <end>\n";
        return 1;
      }

      // Validate priority modifier
      if (priority_mod != "+" && priority_mod != "=" && priority_mod != "-") {
        std::cerr << "Error line " << line_num
                  << ": Priority modifier must be '+', '=', or '-', got: " << priority_mod << "\n";
        return 1;
      }

      // Calculate priority based on modifier and sequence state
      static int current_priority = 0;
      static bool first_in_sequence = true;
      static const SequenceEntry* last_seq = nullptr;

      // Reset priority tracking for new sequence
      if (current_seq != last_seq) {
        current_priority = 0;
        first_in_sequence = true;
        last_seq = current_seq;
      }

      // Handle first effect in sequence
      if (first_in_sequence) {
        if (priority_mod == "-") {
          current_priority = -1;  // Background layer
        } else {
          current_priority = 0;   // Default start (+ or =)
        }
        first_in_sequence = false;
      } else {
        // Update priority based on modifier for subsequent effects
        if (priority_mod == "+") {
          current_priority++;
        } else if (priority_mod == "-") {
          current_priority--;
        }
        // '=' keeps current_priority unchanged
      }

      std::string priority = std::to_string(current_priority);

      // Convert beat notation to time
      std::string start_time = convert_to_time(start, bpm);
      std::string end_time = convert_to_time(end, bpm);

      // Capture remaining args (but strip inline comments)
      std::string rest_of_line;
      std::getline(ss, rest_of_line); // Read rest of line
      // Strip inline comments (everything from '#' onwards)
      size_t comment_pos = rest_of_line.find('#');
      if (comment_pos != std::string::npos) {
        rest_of_line = rest_of_line.substr(0, comment_pos);
      }
      // Remove leading/trailing whitespace
      rest_of_line = trim(rest_of_line);

      std::string extra_args = "";
      if (!rest_of_line.empty()) {
        extra_args = ", " + rest_of_line;
      }

      current_seq->effects.push_back(
          {class_name, start_time, end_time, priority, extra_args});
    } else {
      std::cerr << "Error line " << line_num << ": Unknown command '" << command
                << "'\n";
      return 1;
    }
  }

  // Sort sequences by priority
  std::sort(sequences.begin(), sequences.end(),
            [](const SequenceEntry& a, const SequenceEntry& b) {
              return std::stoi(a.priority) < std::stoi(b.priority);
            });

  // Sort effects within each sequence by priority
  for (auto& seq : sequences) {
    std::sort(seq.effects.begin(), seq.effects.end(),
              [](const EffectEntry& a, const EffectEntry& b) {
                return std::stoi(a.priority) < std::stoi(b.priority);
              });
  }

  // Generate C++ code if output file is specified
  if (!output_cc.empty()) {
    std::ofstream out_file(output_cc);
    if (!out_file.is_open()) {
      std::cerr << "Error: Could not open output file " << output_cc << "\n";
      return 1;
    }

    out_file << "// Auto-generated by seq_compiler. Do not edit.\n";
    out_file << "#include \"gpu/demo_effects.h\"\n";
    out_file << "#include \"gpu/effect.h\"\n\n";

    // Generate demo duration function
    if (!demo_end_time.empty()) {
      out_file << "float GetDemoDuration() {\n";
      out_file << "  return " << demo_end_time << "f;\n";
      out_file << "}\n\n";
    } else {
      out_file << "float GetDemoDuration() {\n";
      out_file << "  return -1.0f;  // No end time specified\n";
      out_file << "}\n\n";
    }

    out_file << "void LoadTimeline(MainSequence& main_seq, WGPUDevice device, "
                "WGPUQueue queue, WGPUTextureFormat format) {\n";

    for (const SequenceEntry& seq : sequences) {
      out_file << "  {\n";
      out_file << "    auto seq = std::make_shared<Sequence>();\n";
      // Set sequence end time if specified
      if (seq.end_time != "-1.0") {
        out_file << "    seq->set_end_time(" << seq.end_time << "f);\n";
      }
      for (const EffectEntry& eff : seq.effects) {
        out_file << "    seq->add_effect(std::make_shared<" << eff.class_name
                 << ">(device, queue, format" << eff.extra_args << "), "
                 << eff.start << "f, " << eff.end << "f, " << eff.priority
                 << ");\n";
      }
      out_file << "    main_seq.add_sequence(seq, " << seq.start_time << "f, "
               << seq.priority << ");\n";
      out_file << "  }\n";
    }

    out_file << "}\n";
    out_file.close();

    std::cout << "Successfully generated timeline with " << sequences.size()
              << " sequences.\n";
  } else {
    std::cout << "Validation successful: " << sequences.size()
              << " sequences, " << (demo_end_time.empty() ? "no" : "explicit")
              << " end time.\n";
  }

  // Generate Gantt charts if requested
  if (!gantt_output.empty()) {
    generate_gantt_chart(gantt_output, sequences, bpm, demo_end_time);
  }
  if (!gantt_html_output.empty()) {
    generate_gantt_html(gantt_html_output, sequences, bpm, demo_end_time);
  }

  return 0;
}