#pragma once

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

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

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

     const std::map<char, std::set<size_t>>& GetTransitions() const;
     const std::map<char, std::set<size_t>>& GetBackTransitions() const;

     void AddEdge(char, size_t);
     void RemoveEdge(char, size_t);
     void SetOwner(NFATree* owner);
     void SetFinal(bool status);
     void SetStart(bool status);
    private:
     NFATree* owner_;
     std::map<char, std::set<size_t>> transitions_;
     std::map<char, std::set<size_t>> back_transitions_;

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

     friend class NFATree;
  };

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

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

  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_;
};
}