#pragma once

#include <map>
#include <vector>
#include <set>
#include <memory>

namespace NFA {
class NFATree {
 public:
  class Vertex {
    public:
     Vertex();

     bool IsFinal() const;
     bool IsStart() const;
     size_t GetNumber() const;

     std::multimap<char, size_t> transitions;
    private:
     Vertex(bool is_final, bool is_start);

     size_t number_;
     bool is_final_ = false;
     bool is_start_ = false;

     friend class NFATree;
  };

  NFATree() = default;
  NFATree(const NFATree&) = delete;
  NFATree(NFATree&&) = default;

  NFATree& operator=(const NFATree&) = delete;
  NFATree& operator=(NFATree&&) = default;

  size_t AddNewVertex();
  void AddFinalVertex(size_t number);
  void AddStartVertex(size_t number);

  void RemoveVertex(size_t number);
  void RemoveFinalVertex(size_t number);
  void RemoveStartVertex(size_t number);

  void Composition(NFATree&&,
                   std::vector<size_t> start_vertexes,
                   std::vector<size_t> final_vertexes);

  std::shared_ptr<Vertex> GetVertex(size_t number);
  size_t GetCountVertexes() const;
  const std::vector<size_t>& GetFinalVertexes() const;
  const std::vector<size_t>& GetStartVertexes() const;

  void Print() const;
 private:
  size_t count_vertexes_ = 0;
  std::map<size_t, std::shared_ptr<Vertex>> vertexes_;
  std::vector<size_t> final_vertexes_;
  std::vector<size_t> start_vertexes_;
};
}