using System;
using System.Collections.Generic;
using HeuristicLab.Persistence.Core.Tokens;

namespace HeuristicLab.Persistence.Core {

  public sealed class TypeCache {

    private Dictionary<Type, int> type2id;
    private Dictionary<int, Type> id2serializer;
    private Type unpublishedType;
    private int? unpublishedSerializer;

    public bool HasUnpublishedType { get { return unpublishedType != null; } }
    public bool HasUnpublishedSerializer { get { return unpublishedSerializer != null; } }

    public TypeToken PublishUnpublishedType() {
      TypeToken token = new TypeToken(type2id[unpublishedType], unpublishedType.AssemblyQualifiedName);
      unpublishedType = null;
      return token;
    }

    public SerializerToken PublishUnpublishedSerializer() {
      SerializerToken token = new SerializerToken((int)unpublishedSerializer, id2serializer[(int)unpublishedSerializer].AssemblyQualifiedName);
      unpublishedSerializer = null;
      return token;
    }

    public TypeCache() {
      type2id = new Dictionary<Type, int>();
      id2serializer = new Dictionary<int, Type>();
    }

    public IEnumerable<Type> Types { get { return type2id.Keys; } }

    public int GetOrCreateId(Type type) {
      int id;
      if (!type2id.TryGetValue(type, out id)) {
        id = type2id.Count;
        type2id.Add(type, id);
        unpublishedType = type;
      }
      return id;
    }

    public void SetSerializer(int typeId, Type serializerType) {
      Type serializer;
      if (!id2serializer.TryGetValue(typeId, out serializer)) {
        id2serializer.Add(typeId, serializerType);
        unpublishedSerializer = typeId;
      }
    }

    public Type GetSerializer(int id) {
      Type serializer = null;
      id2serializer.TryGetValue(id, out serializer);
      return serializer;
    }

    public ReverseTypeCache Reverse() {
      var reverse = new ReverseTypeCache();
      foreach (var t in type2id)
        reverse.AddType(t.Value, t.Key);
      foreach (var s in id2serializer)
        reverse.AddSerializer(s.Key, s.Value);
      return reverse;
    }
  }
}