import 'dart:io';

abstract class TabNode {}

enum TabType {
  BASS,
  GUITAR,
}

// TODO
enum NoteLetter {
  E,
  F,
  G,
  A,
  B,
  C,
  D,
}

class Note {
  NoteLetter letter;
  bool sharp;

  Note({this.letter, this.sharp});
}

class HammerOnEvent extends FretEvent {
  int fromFret;
  int toFret;
  int delta;
  HammerOnEvent({this.fromFret, this.toFret, this.delta});
}

class SlideEvent extends FretEvent {
  int fromFret;
  int toFret;
  int delta;
  SlideEvent({this.fromFret, this.toFret, this.delta});
}

class NoteFretEvent extends FretEvent {
  int fret;
  int delta;
  NoteFretEvent({this.fret, this.delta});
}

class FretEvent {
  int delta;
}

class NewFretEvent {
  int offset = -1;
  int index;
  EventType type;
  List<String> bits = List();
  List<int> frets = List();
  NewFretEvent();
}

class SingleString {
  String note;
  List<NewFretEvent> events;
  SingleString({this.events, this.note});
}

abstract class TabElement {}

class SingleTabulatureElement extends TabElement {
  TabType type;
  int length;
  List<SingleString> strings;

  SingleTabulatureElement({this.type, this.length, this.strings});
}

enum EventType {
  HAMMER_ON,
  SLIDE,
  SINGLE_NOTE,
  SEPARATOR,
  STRING_IDENTIFIER,
  SPACE,
  VIRBRATO,
  DEAD_NOTE,
  SLIDE_UP,
  SLIDE_DOWN,
  PULL_OFF,
  TEXT,
}

class Single {}

class TextTabElement extends TabElement {
  String content;

  TextTabElement({this.content});
}

enum LineParseResult {
  TAB,
  TEXT,
}

class EventsParser {
  final String stringText;

  EventsParser({this.stringText});

  String noteIdentifier;
  int parseIndex = 0;
  List<NewFretEvent> events = List();
  NewFretEvent currentFretEvent;

  List<NewFretEvent> parseEvents() {
    while (parseIndex < stringText.length) {
      parseEvent();
      currentFretEvent.offset = parseIndex - 1;

      events.add(currentFretEvent);
      currentFretEvent = null;
    }
    return events.where((e) => e != null && e.type != null).toList();
  }

  void parseEvent() {
    print("index: " + parseIndex.toString());
    if (parseIndex >= stringText.length) return;
    if (currentFretEvent == null) {
      currentFretEvent = NewFretEvent();
    }

    if ((events.isEmpty ||
            (!(events.last.type == EventType.TEXT &&
                (parseIndex == stringText.length ||
                    stringText[parseIndex + 1] != '-')))) &&
        isANumbericInteger(stringText[parseIndex])) {
      if (currentFretEvent.type == null)
        currentFretEvent.type = EventType.SINGLE_NOTE;
      var number = parseNumber(stringText, parseIndex);
      print(number);
      print(stringText[parseIndex]);
      print(stringText[parseIndex + number.toString().length]);
      parseIndex += number.toString().length;
      currentFretEvent.frets.add(number);
      print("from number");
      parseEvent();
    } else {
      print(stringText[parseIndex]);
      if (stringText[parseIndex] == '|') {
        if (currentFretEvent.type != null) finishEvent();
        currentFretEvent.type = EventType.SEPARATOR;
        parseIndex += 1;
        return;
      } else if (stringText[parseIndex] == '-') {
        if (currentFretEvent.type != null) finishEvent();

        currentFretEvent.type = EventType.SPACE;
        parseIndex += 1;
        return;
      }

      if (currentFretEvent.frets.isNotEmpty) {
        if (stringText[parseIndex] == 'h') {
          currentFretEvent.type = EventType.HAMMER_ON;
          parseIndex += 1;
          parseEvent();
        } else if (stringText[parseIndex] == 's') {
          currentFretEvent.type = EventType.SLIDE;

          parseIndex += 1;
          parseEvent();
        } else if (stringText[parseIndex] == 'p') {
          currentFretEvent.type = EventType.PULL_OFF;
          parseIndex += 1;
          parseEvent();
        } else if (stringText[parseIndex] == '/') {
          currentFretEvent.type = EventType.SLIDE;
          print("from slide");
          parseIndex += 1;
          parseEvent();
        } else if (stringText[parseIndex] == '\\') {
          currentFretEvent.type = EventType.SLIDE;
          parseIndex += 1;
          parseEvent();
        }
      } else {
        if (stringText[parseIndex] == '/') {
          currentFretEvent.type = EventType.SLIDE;
          print("from slide");
          parseIndex += 1;
          parseEvent();
        } else if (stringText[parseIndex] == '\\') {
          currentFretEvent.type = EventType.SLIDE;
          parseIndex += 1;
          parseEvent();
        } else if (stringText[parseIndex] == 'x') {
          currentFretEvent.type = EventType.DEAD_NOTE;
          parseIndex += 1;
          parseEvent();
        } else {
          if (parseIndex == 0) {
            currentFretEvent.type = EventType.STRING_IDENTIFIER;
            currentFretEvent.bits.add(stringText[parseIndex]);
            parseIndex += 1;
          } else {
            currentFretEvent.type = EventType.TEXT;
            currentFretEvent.bits.add(stringText[parseIndex]);
            parseIndex += 1;
          }
        }
      }
    }
  }

  void finishEvent() {
    if (currentFretEvent != null) {
      currentFretEvent.offset = parseIndex - 1;
      events.add(currentFretEvent);
    }
    currentFretEvent = NewFretEvent();
  }

  int parseNumber(String sequence, int currentIndex) {
    var number = int.parse(sequence[currentIndex]);
    var numString = number.toString();
    if ((currentIndex + 1) < sequence.length) {
      if (isANumbericInteger(sequence[currentIndex + 1]) && number < 2) {
        numString += parseNumber(sequence, currentIndex + 1).toString();
      }
    }
    return int.parse(numString);
  }
}

class TabulatureParser {
  File activeFile;
  int currentLineIndex = 0;
  SingleTabulatureElement currentTab;
  LineParseResult lastParseResult;
  List<String> lines;
  List<TabElement> elements = List();

  TabulatureParser();

  Future<List<TabElement>> parseFile(File file) async {
    lines = await file.readAsLines();
    while (currentLineIndex < lines.length) {
      readLine();
    }
    return elements;
  }

  void readLine() {
    var line = lines[currentLineIndex];
    var events = EventsParser(stringText: line).parseEvents();
    events.forEach((e) {
      print(e.type);
    });
    var verifyLineElements =
        events.where((e) => e.type != EventType.SPACE).toList();
    if (verifyLineElements[0].type == EventType.STRING_IDENTIFIER &&
        verifyLineElements[1].type == EventType.SEPARATOR) {
      print("TAB");
    } else {
      print("TEXT");
    }

    currentLineIndex += 1;
  }

  /*
    if (line.length > 0 && line[1] == '|') {
      if (lastParseResult != LineParseResult.TAB && currentTab != null) {
        elements.add(currentTab);
        currentTab = null;
      }
      // print('Found string ${line[0]}');

      var currentStringParseIndex = 0;
      List<FretEvent> events = List();
      var eventDelta = 0;
      var started = false;
      var startIndex;
      var endIndex;

      var eventStarted = false;
      List<String> eventBits = [];

      while (currentStringParseIndex < line.length) {
        var events = EventsParser(stringText: line).parseEvents();
        var verifyLineElements = events.where((e) => e.type != EventType.SPACE).toList();
        if (verifyLineElements[0].type == EventType.STRING_IDENTIFIER && verifyLineElements[1].type == EventType.SEPARATOR) {

        }
/*
      while (currentStringParseIndex < line.length) {
        if (line[currentStringParseIndex] == '|' &&
            line[currentStringParseIndex - 1] != '-') {
          started = !started;
          if (started) {
            startIndex = currentStringParseIndex;
          } else {
            endIndex = currentStringParseIndex;
          }
          currentStringParseIndex += 1;
        } else if (line[currentStringParseIndex] == '-') {
          if (started) eventDelta += 1;
          currentStringParseIndex += 1;
        } else {
          if (isANumbericInteger(line[currentStringParseIndex])) {
            var number = parseNumber(line, currentStringParseIndex);
            currentStringParseIndex += number.toString().length;

            // 🥖 ayy
            if (line[currentStringParseIndex] == 'h') {
              currentStringParseIndex += 1;
              // HAMMERR ON
              var nextNum = parseNumber(line, currentStringParseIndex);
              currentStringParseIndex += nextNum.toString().length;
              events.add(
                HammerOnEvent(
                  fromFret: number,
                  toFret: number,
                  delta: eventDelta,
                ),
              );
            } else if (line[currentStringParseIndex] == '/') {
              // SLIDEE
              currentStringParseIndex += 1;
              var nextNum = parseNumber(line, currentStringParseIndex);
              currentStringParseIndex += nextNum.toString().length;
              events.add(
                SlideEvent(
                  fromFret: number,
                  toFret: number,
                  delta: eventDelta,
                ),
              );
            } else {
              events.add(
                NoteFretEvent(
                  fret: number,
                  delta: eventDelta,
                ),
              );
            }
            eventDelta = 0;
          } else {
            if (started) eventDelta += 1;
            currentStringParseIndex += 1;
          }
        }
      }

      if (endIndex == null) {
        endIndex = line.length;
      }

      if (currentTab == null) {
        currentTab = SingleTabulatureElement(
          length: endIndex - startIndex,
          strings: [],
        );
      }

      currentTab.strings.add(
        SingleString(
          note: line[0],
          events: events,
        ),
      );

      lastParseResult = LineParseResult.TAB;

      if (currentLineIndex + 1 == lines.length ||
          !(lines[currentLineIndex + 1].length > 0 &&
              lines[currentLineIndex + 1][1] == '|')) {
        elements.add(currentTab);
        currentTab = null;
      }
    } else {
      elements.add(TextTabElement(
        content: line,
      ));
      lastParseResult = LineParseResult.TEXT;
    }
*/
    }
    currentLineIndex += 1;
  }*/

  int parseNumber(String sequence, int currentIndex) {
    var number = int.parse(sequence[currentIndex]);
    var numString = number.toString();
    if (isANumbericInteger(sequence[currentIndex + 1]) && number < 2) {
      numString += parseNumber(sequence, currentIndex + 1).toString();
    }
    return int.parse(numString);
  }
}

void main(List<String> args) async {
  var file = File('tab.txt');
  var res = await TabulatureParser().parseFile(file);
  res.forEach((e) {
    if (e is SingleTabulatureElement) {
      print(e.strings.map((e) => e.note).join(', '));
    } else if (e is TextTabElement) {
      print(e.content);
    }
  });
}

bool isANumbericInteger(String s) {
  if (s == null) {
    return false;
  }
  try {
    return int.parse(s) != null;
  } catch (e) {
    return false;
  }
}