#include <iostream>
#include <list>
#include <memory>
#include <string>
#include <vector>
#include <fstream>
#include <unordered_map>
#include <stack>
#include <regex>


///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////

// std::stringから先頭の空白を削除する関数
std::string trimLeadingWhitespace(const std::string& str) {
  size_t start = str.find_first_not_of(" \t\n\r");
  return (start == std::string::npos) ? "" : str.substr(start);
}
// std::stringから、冒頭のアルファベットのみの文字列を取得。
std::string getLeadingAlphabet(const std::string& str) {
  size_t end = str.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
  return (end == std::string::npos) ? str : str.substr(0, end);
}

bool isSectionMarks(const std::string& str) {
  // セクションの開始を示す文字列かどうかを判定
  // ここでは例として "Project" と "Global" をセクションの開始とする
  return 
    str == "Project" || 
    str == "ProjectSection" ||
    str == "EndProjectSection" ||
    str == "EndProject" ||
    str == "Global" ||
    str == "GlobalSection" ||
    str == "EndGlobalSection" ||
    str == "EndGlobal"
    ;
}

// slnファイルの各行を表すクラス
class LineData {

protected:
    std::string line;
public:
  void setLine(const std::string& text) {
    line = text;
  }
  const std::string& getLine() const {
    return line;
  }
  std::string& getLine() {
    return line;
  }
};

// ヘッダはセクション扱いとはしないで各行を独自の情報とみなす
class HeaderLine :public LineData {
protected:
  std::regex pattern;
public:
  HeaderLine(std::string pat) :pattern(pat) {
  }
  virtual std::string getVersion() const{
    std::string text = getLine();
    std::smatch match;
    std::regex_search(text, match, pattern);
    return text.substr(match.position(1), match.length(1));
  }
  virtual void setVersion(const std::string& newvalue) {
    std::string text = getLine();
    std::smatch match;
    std::regex_search(text, match, pattern);
    text.replace(match.position(1), match.length(1), newvalue);
    setLine(text);
  }
};

// Visual Studioのバージョン情報を保持するクラス
class VisualStudioVersion : public HeaderLine {

public:
  VisualStudioVersion():
    HeaderLine(R"(^VisualStudioVersion\s*=\s*([0-9.]+))") 
  {
  }
};

// 最小Visual Studioのバージョン情報を保持するクラス
class MinimumVisualStudioVersion : public HeaderLine {

public:
  MinimumVisualStudioVersion():
    HeaderLine(R"(^MinimumVisualStudioVersion\s*=\s*([0-9.]+))")
  {
  }
};

// ソリューションファイルのフォーマットバージョンを保持するクラス
class FormatVersion : public HeaderLine {

public:
  FormatVersion():
    HeaderLine(R"(Format Version ([0-9.]+))")
  {
  }
};

enum class HeaderLineTypeT {
  HL_VisualStudioVersion,
  HL_MinimumVisualStudioVersion,
  HL_FormatVersion,
  HL_ERROR
};
HeaderLineTypeT HeaderLineType(const std::string& line) {
  std::regex format_version_regex(R"(Format Version ([0-9.]+))");
  std::regex visual_studio_version_regex(R"(^VisualStudioVersion\s*=\s*([0-9.]+))");
  std::regex minimum_visual_studio_version_regex(R"(^MinimumVisualStudioVersion\s*=\s*([0-9.]+))");

  std::smatch match;

  if (std::regex_search(line, match, format_version_regex)) {
    return HeaderLineTypeT::HL_FormatVersion;
  }
  else if (std::regex_search(line, match, visual_studio_version_regex)) {
    return HeaderLineTypeT::HL_VisualStudioVersion;
  }
  else if (std::regex_search(line, match, minimum_visual_studio_version_regex)) {
    return HeaderLineTypeT::HL_MinimumVisualStudioVersion;
  }
  return HeaderLineTypeT::HL_ERROR;
}

using SlnFileLineSPtr = std::shared_ptr<LineData>;

class Section : public std::enable_shared_from_this<Section> {
protected:
    std::list< SlnFileLineSPtr > ::iterator head;
    std::list< SlnFileLineSPtr > ::iterator tail;
  std::string _sectionType;
public:
    std::list < std::shared_ptr<Section> > subSections; // サブセクションのリスト
    std::shared_ptr<Section> This() { return shared_from_this(); }

  std::list < std::shared_ptr<Section> >& getSubSections(){
    // グローバルセクションのサブセクションを取得するメソッド
    return subSections;
  }

  virtual void update() {}


  Section(std::string sectionname, std::list< SlnFileLineSPtr >::iterator shead) {
    head = shead;
    _sectionType = sectionname;
  }
  std::string getSectionType()const {
    return _sectionType;
  }
  void setSectionTail(std::list< SlnFileLineSPtr >::iterator stail) {
    tail = stail;
  }

  std::list< SlnFileLineSPtr > ::iterator getSectionBegin() const {
    return head;
  }
  std::list< SlnFileLineSPtr > ::iterator getSectionTail() const {
    return tail;
  }

  std::list< SlnFileLineSPtr > ::iterator getSectionEnd() const {
    auto itr = tail;
    itr++;
    return itr;
  }
};

class GlobalSection : public Section {
protected:

  std::string* sectionHeadLine() {
    return & (*getSectionBegin())->getLine();
  }
  const std::string* sectionHeadLine() const{
    return & (*getSectionBegin())->getLine();
  }

  std::regex Pattern;
public:
  GlobalSection(std::string sectionname, std::list< SlnFileLineSPtr >::iterator line):Section(sectionname,line) {

    Pattern = std::regex(R"(^\s*GlobalSection\((\w+)\)\s*=\s*(preSolution|postSolution))");
  }


  std::string getSectionName()const{

    std::string slice;
    std::smatch match;
    if (std::regex_match(*sectionHeadLine(), match, Pattern)) {
      // セクション名をスライスで保存
      slice = sectionHeadLine()->substr(match.position(1), match.length(1));
    }

    return slice;
  }
  void setSectionName(const std::string& newvalue) {
    std::string slice;
    std::smatch match;
    if (std::regex_match(*sectionHeadLine(), match, Pattern)) {
      sectionHeadLine()->replace(match.position(1), match.length(1), newvalue);
    }
  }

  void setSectionTiming(const std::string& newvalue) {
    std::string slice;
    std::smatch match;
    if (std::regex_match(*sectionHeadLine(), match, Pattern)) {
      sectionHeadLine()->replace(match.position(2), match.length(2), newvalue);
    }
  }

  std::string getSectionTiming() const {
    std::string slice;
    std::smatch match;
    if (std::regex_match(*sectionHeadLine(), match, Pattern)) {
      slice = sectionHeadLine()->substr(match.position(2), match.length(2));
    }
    return slice;

  }

};