#include "notification.h"
#include <cassert>
#include <new>
#include <json.hpp>
#include "codes.h"
#include "client.h"

namespace twitter {

  notification::type notification::getType() const
  {
    return _type;
  }

  notification::notification(const user& current_user, std::string data)
  {
    nlohmann::json json;

    try
    {
      json = nlohmann::json::parse(data);
    } catch (const std::invalid_argument& error)
    {
      std::throw_with_nested(invalid_response(data));
    }

    try
    {
      if (!json["event"].is_null())
      {
        std::string event = json["event"];
        user source(json["source"].dump());
        user target(json["target"].dump());

        if (event == "user_update")
        {
          _type = type::update_user;

          new(&_user) user(source);
        } else if (event == "block")
        {
          _type = type::block;

          new(&_user) user(target);
        } else if (event == "unblock")
        {
          _type = type::unblock;

          new(&_user) user(target);
        } else if (event == "favorite")
        {
          new(&_user_and_tweet._tweet) tweet(json["target_object"].dump());

          if (current_user == source)
          {
            _type = type::favorite;

            new(&_user_and_tweet._user) user(target);
          } else {
            _type = type::favorited;

            new(&_user_and_tweet._user) user(source);
          }
        } else if (event == "unfavorite")
        {
          new(&_user_and_tweet._tweet) tweet(json["target_object"].dump());

          if (current_user == source)
          {
            _type = type::unfavorite;

            new(&_user_and_tweet._user) user(target);
          } else {
            _type = type::unfavorited;

            new(&_user_and_tweet._user) user(source);
          }
        } else if (event == "follow")
        {
          if (current_user == source)
          {
            _type = type::follow;

            new(&_user) user(target);
          } else {
            _type = type::followed;

            new(&_user) user(source);
          }
        } else if (event == "unfollow")
        {
          _type = type::unfollow;

          new(&_user) user(target);
        } else if (event == "list_created")
        {
          _type = type::list_created;

          new(&_list) list(json["target_object"].dump());
        } else if (event == "list_destroyed")
        {
          _type = type::list_destroyed;

          new(&_list) list(json["target_object"].dump());
        } else if (event == "list_updated")
        {
          _type = type::list_updated;

          new(&_list) list(json["target_object"].dump());
        } else if (event == "list_member_added")
        {
          new(&_user_and_list._list) list(json["target_object"].dump());

          if (current_user == source)
          {
            _type = type::list_add;

            new(&_user_and_list._user) user(target);
          } else {
            _type = type::list_added;

            new(&_user_and_list._user) user(source);
          }
        } else if (event == "list_member_removed")
        {
          new(&_user_and_list._list) list(json["target_object"].dump());

          if (current_user == source)
          {
            _type = type::list_remove;

            new(&_user_and_list._user) user(target);
          } else {
            _type = type::list_removed;

            new(&_user_and_list._user) user(source);
          }
        } else if (event == "list_member_subscribe")
        {
          new(&_user_and_list._list) list(json["target_object"].dump());

          if (current_user == source)
          {
            _type = type::list_subscribe;

            new(&_user_and_list._user) user(target);
          } else {
            _type = type::list_subscribed;

            new(&_user_and_list._user) user(source);
          }
        } else if (event == "list_member_unsubscribe")
        {
          new(&_user_and_list._list) list(json["target_object"].dump());

          if (current_user == source)
          {
            _type = type::list_unsubscribe;

            new(&_user_and_list._user) user(target);
          } else {
            _type = type::list_unsubscribed;

            new(&_user_and_list._user) user(source);
          }
        } else if (event == "quoted_tweet")
        {
          _type = type::quoted;

          new(&_user_and_tweet._user) user(source);
          new(&_user_and_tweet._tweet) tweet(json["target_object"].dump());
        } else {
          _type = type::unknown;
        }
      } else if (!json["warning"].is_null())
      {
        new(&_warning) std::string(json["warning"]["message"].get<std::string>());

        auto warning_code = json["warning"]["code"].get<std::string>();
        if (warning_code == "FALLING_BEHIND")
        {
          _type = type::stall;
        } else if (warning_code == "FOLLOWS_OVER_LIMIT")
        {
          _type = type::follow_limit;
        } else {
          _type = type::unknown_warning;
        }
      } else if (!json["delete"].is_null())
      {
        _type = type::deletion;

        _user_id_and_tweet_id._tweet_id = json["delete"]["status"]["id"].get<tweet_id>();
        _user_id_and_tweet_id._user_id = json["delete"]["status"]["user_id"].get<user_id>();
      } else if (!json["scrub_geo"].is_null())
      {
        _type = type::scrub_location;

        _user_id_and_tweet_id._tweet_id = json["scrub_geo"]["up_to_status_id"].get<tweet_id>();
        _user_id_and_tweet_id._user_id = json["scrub_geo"]["user_id"].get<user_id>();
      } else if (!json["limit"].is_null())
      {
        _type = type::limit;

        _limit = json["limit"]["track"].get<int>();
      } else if (!json["status_withheld"].is_null())
      {
        _type = type::withhold_status;

        _withhold_status._user_id = json["status_withheld"]["user_id"].get<user_id>();
        _withhold_status._tweet_id = json["status_withheld"]["id"].get<tweet_id>();

        new(&_withhold_status._countries) std::vector<std::string>();
        for (auto s : json["status_withheld"]["withheld_in_countries"])
        {
          _withhold_status._countries.push_back(s);
        }
      } else if (!json["user_withheld"].is_null())
      {
        _type = type::withhold_user;

        _withhold_user._user_id = json["user_withheld"]["id"].get<user_id>();

        new(&_withhold_user._countries) std::vector<std::string>();
        for (auto s : json["user_withheld"]["withheld_in_countries"])
        {
          _withhold_user._countries.push_back(s);
        }
      } else if (!json["disconnect"].is_null())
      {
        _type = type::disconnect;

        switch (json["disconnect"]["code"].get<int>())
        {
          case 1: _disconnect = disconnect_code::shutdown; break;
          case 2: _disconnect = disconnect_code::duplicate; break;
          case 4: _disconnect = disconnect_code::stall; break;
          case 5: _disconnect = disconnect_code::normal; break;
          case 6: _disconnect = disconnect_code::token_revoked; break;
          case 7: _disconnect = disconnect_code::admin_logout; break;
          case 9: _disconnect = disconnect_code::limit; break;
          case 10: _disconnect = disconnect_code::exception; break;
          case 11: _disconnect = disconnect_code::broker; break;
          case 12: _disconnect = disconnect_code::load; break;
          default: _disconnect = disconnect_code::unknown;
        }
      } else if (!json["friends"].is_null())
      {
        _type = type::friends;

        new(&_friends) std::set<user_id>(std::begin(json["friends"]), std::end(json["friends"]));
      } else if (!json["direct_message"].is_null())
      {
        _type = type::direct;

        new(&_direct_message) direct_message(json["direct_message"].dump());
      } else {
        _type = type::tweet;

        new(&_tweet) tweet(data);
      }
    } catch (const std::domain_error& error)
    {
      std::throw_with_nested(invalid_response(data));
    }
  }

  notification::notification(const notification& other)
  {
    _type = other._type;

    switch (_type)
    {
      case type::tweet:
      {
        new(&_tweet) tweet(other._tweet);

        break;
      }

      case type::update_user:
      case type::block:
      case type::unblock:
      case type::follow:
      case type::followed:
      case type::unfollow:
      {
        new(&_user) user(other._user);

        break;
      }

      case type::favorite:
      case type::favorited:
      case type::unfavorite:
      case type::unfavorited:
      case type::quoted:
      {
        new(&_user_and_tweet._user) user(other._user_and_tweet._user);
        new(&_user_and_tweet._tweet) tweet(other._user_and_tweet._tweet);

        break;
      }

      case type::list_created:
      case type::list_destroyed:
      case type::list_updated:
      {
        new(&_list) list(other._list);

        break;
      }

      case type::list_add:
      case type::list_added:
      case type::list_remove:
      case type::list_removed:
      case type::list_subscribe:
      case type::list_subscribed:
      case type::list_unsubscribe:
      case type::list_unsubscribed:
      {
        new(&_user_and_list._user) user(other._user_and_list._user);
        new(&_user_and_list._list) list(other._user_and_list._list);

        break;
      }

      case type::stall:
      case type::follow_limit:
      case type::unknown_warning:
      {
        new(&_warning) std::string(other._warning);

        break;
      }

      case type::deletion:
      case type::scrub_location:
      {
        _user_id_and_tweet_id._user_id = other._user_id_and_tweet_id._user_id;
        _user_id_and_tweet_id._tweet_id = other._user_id_and_tweet_id._tweet_id;

        break;
      }

      case type::limit:
      {
        _limit = other._limit;

        break;
      }

      case type::withhold_status:
      {
        _withhold_status._user_id = other._withhold_status._user_id;
        _withhold_status._tweet_id = other._withhold_status._tweet_id;
        new(&_withhold_status._countries) std::vector<std::string>(other._withhold_status._countries);

        break;
      }

      case type::withhold_user:
      {
        _withhold_user._user_id = other._withhold_user._user_id;
        new(&_withhold_user._countries) std::vector<std::string>(other._withhold_user._countries);

        break;
      }

      case type::disconnect:
      {
        _disconnect = other._disconnect;

        break;
      }

      case type::friends:
      {
        new(&_friends) std::set<user_id>(other._friends);

        break;
      }

      case type::direct:
      {
        new(&_direct_message) direct_message(other._direct_message);

        break;
      }

      case type::unknown:
      case type::invalid:
      {
        break;
      }
    }
  }

  notification::notification(notification&& other) : notification()
  {
    swap(*this, other);
  }

  notification& notification::operator=(notification other)
  {
    swap(*this, other);

    return *this;
  }

  notification::~notification()
  {
    switch (_type)
    {
      case type::tweet:
      {
        _tweet.~tweet();

        break;
      }

      case type::update_user:
      case type::block:
      case type::unblock:
      case type::follow:
      case type::followed:
      case type::unfollow:
      {
        _user.~user();

        break;
      }

      case type::favorite:
      case type::favorited:
      case type::unfavorite:
      case type::unfavorited:
      case type::quoted:
      {
        _user_and_tweet._user.~user();
        _user_and_tweet._tweet.~tweet();

        break;
      }

      case type::list_created:
      case type::list_destroyed:
      case type::list_updated:
      {
        _list.~list();

        break;
      }

      case type::list_add:
      case type::list_added:
      case type::list_remove:
      case type::list_removed:
      case type::list_subscribe:
      case type::list_subscribed:
      case type::list_unsubscribe:
      case type::list_unsubscribed:
      {
        _user_and_list._user.~user();
        _user_and_list._list.~list();

        break;
      }

      case type::stall:
      case type::follow_limit:
      case type::unknown_warning:
      {
        using string_type = std::string;
        _warning.~string_type();

        break;
      }

      case type::withhold_status:
      {
        using list_type = std::vector<std::string>;
        _withhold_status._countries.~list_type();

        break;
      }

      case type::withhold_user:
      {
        using list_type = std::vector<std::string>;
        _withhold_user._countries.~list_type();

        break;
      }

      case type::friends:
      {
        using list_type = std::set<user_id>;
        _friends.~list_type();

        break;
      }

      case type::direct:
      {
        _direct_message.~direct_message();

        break;
      }

      case type::deletion:
      case type::scrub_location:
      case type::limit:
      case type::disconnect:
      case type::unknown:
      case type::invalid:
      {
        break;
      }
    }
  }

  void swap(notification& first, notification& second)
  {
    using type = notification::type;

    type tempType = first._type;
    tweet tempTweet;
    user tempUser;
    list tempList;
    std::string tempWarning;
    user_id tempUserId;
    tweet_id tempTweetId;
    int tempLimit;
    std::vector<std::string> tempCountries;
    disconnect_code tempDisconnectCode;
    std::set<user_id> tempFriends;
    direct_message tempDirectMessage;

    switch (first._type)
    {
      case type::tweet:
      {
        tempTweet = std::move(first._tweet);

        break;
      }

      case type::update_user:
      case type::block:
      case type::unblock:
      case type::follow:
      case type::followed:
      case type::unfollow:
      {
        tempUser = std::move(first._user);

        break;
      }

      case type::favorite:
      case type::favorited:
      case type::unfavorite:
      case type::unfavorited:
      case type::quoted:
      {
        tempTweet = std::move(first._user_and_tweet._tweet);
        tempUser = std::move(first._user_and_tweet._user);

        break;
      }

      case type::list_created:
      case type::list_destroyed:
      case type::list_updated:
      {
        tempList = std::move(first._list);

        break;
      }

      case type::list_add:
      case type::list_added:
      case type::list_remove:
      case type::list_removed:
      case type::list_subscribe:
      case type::list_subscribed:
      case type::list_unsubscribe:
      case type::list_unsubscribed:
      {
        tempList = std::move(first._user_and_list._list);
        tempUser = std::move(first._user_and_list._user);

        break;
      }

      case type::stall:
      case type::follow_limit:
      case type::unknown_warning:
      {
        tempWarning = std::move(first._warning);

        break;
      }

      case type::deletion:
      case type::scrub_location:
      {
        tempUserId = first._user_id_and_tweet_id._user_id;
        tempTweetId = first._user_id_and_tweet_id._tweet_id;

        break;
      }

      case type::limit:
      {
        tempLimit = first._limit;

        break;
      }

      case type::withhold_status:
      {
        tempUserId = first._withhold_status._user_id;
        tempTweetId = first._withhold_status._tweet_id;
        tempCountries = std::move(first._withhold_status._countries);

        break;
      }

      case type::withhold_user:
      {
        tempUserId = first._withhold_user._user_id;
        tempCountries = std::move(first._withhold_user._countries);

        break;
      }

      case type::disconnect:
      {
        tempDisconnectCode = first._disconnect;

        break;
      }

      case type::friends:
      {
        tempFriends = std::move(first._friends);

        break;
      }

      case type::direct:
      {
        tempDirectMessage = std::move(first._direct_message);

        break;
      }

      case type::invalid:
      case type::unknown:
      {
        break;
      }
    }

    first.~notification();

    first._type = second._type;

    // Okay now you need to initialize the first with the data from the second
    // And then destruct the second and initialize it with the data stored in temp
    // This is hell

    switch (second._type)
    {
      case type::tweet:
      {
        new(&first._tweet) tweet(std::move(second._tweet));

        break;
      }

      case type::update_user:
      case type::block:
      case type::unblock:
      case type::follow:
      case type::followed:
      case type::unfollow:
      {
        new(&first._user) user(std::move(second._user));

        break;
      }

      case type::favorite:
      case type::favorited:
      case type::unfavorite:
      case type::unfavorited:
      case type::quoted:
      {
        new(&first._user_and_tweet._user) user(std::move(second._user_and_tweet._user));
        new(&first._user_and_tweet._tweet) tweet(std::move(second._user_and_tweet._tweet));

        break;
      }

      case type::list_created:
      case type::list_destroyed:
      case type::list_updated:
      {
        new(&first._list) list(std::move(second._list));

        break;
      }

      case type::list_add:
      case type::list_added:
      case type::list_remove:
      case type::list_removed:
      case type::list_subscribe:
      case type::list_subscribed:
      case type::list_unsubscribe:
      case type::list_unsubscribed:
      {
        new(&first._user_and_list._user) user(std::move(second._user_and_list._user));
        new(&first._user_and_list._list) list(std::move(second._user_and_list._list));

        break;
      }

      case type::stall:
      case type::follow_limit:
      case type::unknown_warning:
      {
        new(&first._warning) std::string(std::move(second._warning));

        break;
      }

      case type::deletion:
      case type::scrub_location:
      {
        first._user_id_and_tweet_id._user_id = second._user_id_and_tweet_id._user_id;
        first._user_id_and_tweet_id._tweet_id = second._user_id_and_tweet_id._tweet_id;

        break;
      }

      case type::limit:
      {
        first._limit = second._limit;

        break;
      }

      case type::withhold_status:
      {
        first._withhold_status._user_id = second._withhold_status._user_id;
        first._withhold_status._tweet_id = second._withhold_status._tweet_id;
        new(&first._withhold_status._countries) std::vector<std::string>(std::move(second._withhold_status._countries));

        break;
      }

      case type::withhold_user:
      {
        first._withhold_user._user_id = second._withhold_user._user_id;
        new(&first._withhold_user._countries) std::vector<std::string>(std::move(second._withhold_user._countries));

        break;
      }

      case type::disconnect:
      {
        first._disconnect = second._disconnect;

        break;
      }

      case type::friends:
      {
        new(&first._friends) std::set<user_id>(std::move(second._friends));

        break;
      }

      case type::direct:
      {
        new(&first._direct_message) direct_message(std::move(second._direct_message));

        break;
      }

      case type::invalid:
      case type::unknown:
      {
        break;
      }
    }

    // Now destruct the second and initialize it with data from the first
    second.~notification();

    second._type = tempType;

    switch (tempType)
    {
      case type::tweet:
      {
        new(&second._tweet) tweet(std::move(tempTweet));

        break;
      }

      case type::update_user:
      case type::block:
      case type::unblock:
      case type::follow:
      case type::followed:
      case type::unfollow:
      {
        new(&second._user) user(std::move(tempUser));

        break;
      }

      case type::favorite:
      case type::favorited:
      case type::unfavorite:
      case type::unfavorited:
      case type::quoted:
      {
        new(&second._user_and_tweet._user) user(std::move(tempUser));
        new(&second._user_and_tweet._tweet) tweet(std::move(tempTweet));

        break;
      }

      case type::list_created:
      case type::list_destroyed:
      case type::list_updated:
      {
        new(&second._list) list(std::move(tempList));

        break;
      }

      case type::list_add:
      case type::list_added:
      case type::list_remove:
      case type::list_removed:
      case type::list_subscribe:
      case type::list_subscribed:
      case type::list_unsubscribe:
      case type::list_unsubscribed:
      {
        new(&second._user_and_list._user) user(std::move(tempUser));
        new(&second._user_and_list._list) list(std::move(tempList));

        break;
      }

      case type::stall:
      case type::follow_limit:
      case type::unknown_warning:
      {
        new(&second._warning) std::string(std::move(tempWarning));

        break;
      }

      case type::deletion:
      case type::scrub_location:
      {
        second._user_id_and_tweet_id._user_id = tempUserId;
        second._user_id_and_tweet_id._tweet_id = tempTweetId;

        break;
      }

      case type::limit:
      {
        second._limit = tempLimit;

        break;
      }

      case type::withhold_status:
      {
        second._withhold_status._user_id = tempUserId;
        second._withhold_status._tweet_id = tempTweetId;
        new(&second._withhold_status._countries) std::vector<std::string>(std::move(tempCountries));

        break;
      }

      case type::withhold_user:
      {
        second._withhold_user._user_id = tempUserId;
        new(&second._withhold_user._countries) std::vector<std::string>(std::move(tempCountries));

        break;
      }

      case type::disconnect:
      {
        second._disconnect = tempDisconnectCode;

        break;
      }

      case type::friends:
      {
        new(&second._friends) std::set<user_id>(std::move(tempFriends));

        break;
      }

      case type::direct:
      {
        new(&second._direct_message) direct_message(std::move(tempDirectMessage));

        break;
      }

      case type::invalid:
      case type::unknown:
      {
        break;
      }
    }
  }

  const tweet& notification::getTweet() const
  {
    switch (_type)
    {
      case type::tweet:
      {
        return _tweet;
      }

      case type::favorite:
      case type::favorited:
      case type::unfavorite:
      case type::unfavorited:
      case type::quoted:
      {
        return _user_and_tweet._tweet;
      }

      default:
      {
        assert(false);
      }
    }
  }

  const user& notification::getUser() const
  {
    switch (_type)
    {
      case type::update_user:
      case type::block:
      case type::unblock:
      case type::follow:
      case type::followed:
      case type::unfollow:
      {
        return _user;
      }

      case type::favorite:
      case type::favorited:
      case type::unfavorite:
      case type::unfavorited:
      case type::quoted:
      {
        return _user_and_tweet._user;
      }

      case type::list_add:
      case type::list_added:
      case type::list_remove:
      case type::list_removed:
      case type::list_subscribe:
      case type::list_subscribed:
      case type::list_unsubscribe:
      case type::list_unsubscribed:
      {
        return _user_and_list._user;
      }

      default:
      {
        assert(false);
      }
    }
  }

  const list& notification::getList() const
  {
    switch (_type)
    {
      case type::list_created:
      case type::list_destroyed:
      case type::list_updated:
      {
        return _list;
      }

      case type::list_add:
      case type::list_added:
      case type::list_remove:
      case type::list_removed:
      case type::list_subscribe:
      case type::list_subscribed:
      case type::list_unsubscribe:
      case type::list_unsubscribed:
      {
        return _user_and_list._list;
      }

      default:
      {
        assert(false);
      }
    }
  }

  tweet_id notification::getTweetID() const
  {
    switch (_type)
    {
      case type::deletion:
      case type::scrub_location:
      {
        return _user_id_and_tweet_id._tweet_id;
      }

      case type::withhold_status:
      {
        return _withhold_status._tweet_id;
      }

      default:
      {
        assert(false);
      }
    }
  }

  void notification::setTweetID(tweet_id _arg)
  {
    switch (_type)
    {
      case type::deletion:
      case type::scrub_location:
      {
        _user_id_and_tweet_id._tweet_id = _arg;;
      }

      case type::withhold_status:
      {
        _withhold_status._tweet_id = _arg;
      }

      default:
      {
        assert(false);
      }
    }
  }

  user_id notification::getUserID() const
  {
    switch (_type)
    {
      case type::deletion:
      case type::scrub_location:
      {
        return _user_id_and_tweet_id._user_id;
      }

      case type::withhold_status:
      {
        return _withhold_status._user_id;
      }

      case type::withhold_user:
      {
        return _withhold_user._user_id;
      }

      default:
      {
        assert(false);
      }
    }
  }

  void notification::setUserID(user_id _arg)
  {
    switch (_type)
    {
      case type::deletion:
      case type::scrub_location:
      {
        _user_id_and_tweet_id._user_id = _arg;
      }

      case type::withhold_status:
      {
        _withhold_status._user_id = _arg;
      }

      case type::withhold_user:
      {
        _withhold_user._user_id = _arg;
      }

      default:
      {
        assert(false);
      }
    }
  }

  const std::vector<std::string>& notification::getCountries() const
  {
    switch (_type)
    {
      case type::withhold_status:
      {
        return _withhold_status._countries;
      }

      case type::withhold_user:
      {
        return _withhold_user._countries;
      }

      default:
      {
        assert(false);
      }
    }
  }

  disconnect_code notification::getDisconnectCode() const
  {
    assert(_type == type::disconnect);

    return _disconnect;
  }

  void notification::setDisconnectCode(disconnect_code _arg)
  {
    assert(_type == type::disconnect);

    _disconnect = _arg;
  }

  const std::set<user_id>& notification::getFriends() const
  {
    assert(_type == type::friends);

    return _friends;
  }

  const direct_message& notification::getDirectMessage() const
  {
    assert(_type == type::direct);

    return _direct_message;
  }

  int notification::getLimit() const
  {
    assert(_type == type::limit);

    return _limit;
  }

  void notification::setLimit(int _arg)
  {
    assert(_type == type::limit);

    _limit = _arg;
  }

  const std::string& notification::getWarning() const
  {
    switch (_type)
    {
      case type::stall:
      case type::follow_limit:
      case type::unknown_warning:
      {
        return _warning;
      }

      default:
      {
        assert(false);
      }
    }
  }

};