import 'package:libac_flutter/nbt/impl/ByteArrayTag.dart';
import 'package:libac_flutter/nbt/impl/CompoundTag.dart';
import 'package:libac_flutter/nbt/impl/DoubleTag.dart';
import 'package:libac_flutter/nbt/impl/EndTag.dart';
import 'package:libac_flutter/nbt/impl/FloatTag.dart';
import 'package:libac_flutter/nbt/impl/IntArrayTag.dart';
import 'package:libac_flutter/nbt/impl/IntTag.dart';
import 'package:libac_flutter/nbt/impl/LongTag.dart';
import 'package:libac_flutter/nbt/impl/TagShort.dart';

import 'Stream.dart';
import 'impl/ByteTag.dart';
import 'impl/ListTag.dart';
import 'impl/LongArrayTag.dart';

enum TagType {
  End(0),
  Byte(1),
  Short(2),
  Int(3),
  Long(4),
  Float(5),
  Double(6),
  ByteArray(7),
  String(8),
  List(9),
  Compound(10),
  IntArray(11),
  LongArray(12);

  final int byte;
  const TagType(this.byte);

  static TagType get(int byte) {
    for (TagType type in values) {
      if (type.byte == byte) {
        return type;
      }
    }

    return TagType.End;
  }
}

abstract class Tag {
  int getType() {
    return getTagType().byte;
  }

  TagType getTagType();
  void writeValue(ByteLayer data);
  void readValue(ByteLayer data);
  String? _key;

  String getKey() {
    return (_key == null ? "" : _key!);
  }

  static Tag readNamedTag(ByteLayer data) {
    var type = data.readByte();
    if (type == 0) {
      return new EndTag();
    } else {
      Tag tag = makeTagOfType(TagType.get(type));
      tag._key = data.readString();
      tag.readValue(data);

      return tag;
    }
  }

  static void writeNamedTag(Tag tag, ByteLayer data) {
    data.writeByte(tag.getType());
    if (tag.getType() != 0) {
      data.writeString(tag.getKey());
      tag.writeValue(data);
    }
  }

  bool equals(dynamic object) {
    if (object == null || !(object is Tag)) return false;

    Tag tag = object;
    if (tag.getType() != getType()) return false;

    if (getKey() == null && tag.getKey() != null ||
        tag.getKey() == null && getKey() != null) return false;

    if (getKey() != null && !(getKey() == tag.getKey())) return false;

    return true;
  }
  
  static Tag makeTagOfType(TagType type) {
    switch (type) {
      case TagType.Byte:
        {
          return new ByteTag();
        }
      case TagType.ByteArray:
        {
          return new ByteArrayTag();
        }

      case TagType.Compound:
        {
          return new CompoundTag();
        }
      case TagType.Double:
        {
          return new DoubleTag();
        }
      case TagType.End:
        return new EndTag();
      case TagType.Short:
        return new TagShort(value: 0);
      case TagType.Int:
        return new IntTag();
      case TagType.Long:
        return new LongTag();
      case TagType.Float:
        return new FloatTag();
      case TagType.IntArray:
        {
          return new IntArrayTag();
        }
      case TagType.LongArray:
        {
          return new LongArrayTag();
        }

      case TagType.List:
        {
          return new ListTag();
        }
      }
    }
  }

}