/*
 * libjingle
 * Copyright 2004--2011, Google Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright notice,
 *     this list of conditions and the following disclaimer in the documentation
 *     and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

//this file contains all the json helper methods
#include "talk/app/webrtc_json.h"

#include <stdio.h>
#include <string>

#include "talk/base/json.h"
#include "talk/base/logging.h"
#include "talk/session/phone/mediasessionclient.h"
#include "talk/session/phone/codec.h"
#include "json/json.h"

namespace webrtc {

static const int kIceComponent = 1;
static const int kIceFoundation = 1;

bool GetConnectionMediator(const Json::Value& value, std::string& connectionMediator) {
  if (value.type() != Json::objectValue && value.type() != Json::nullValue) {
    LOG(LS_WARNING) << "Failed to parse stun values" ;
    return false;
  }

  if (!GetStringFromJsonObject(value, "connectionmediator", &connectionMediator)) {
    LOG(LS_WARNING) << "Failed to parse JSON for value: "
                    << value.toStyledString();
    return false;
  }
  return true;
}

bool GetStunServer(const Json::Value& value, StunServiceDetails& stunServer) {
  if (value.type() != Json::objectValue && value.type() != Json::nullValue) {
    LOG(LS_WARNING) << "Failed to parse stun values" ;
    return false;
  }

  Json::Value stun;
  if (GetValueFromJsonObject(value, "stun_service", &stun)) {
    if (stun.type() == Json::objectValue) {
      if (!GetStringFromJsonObject(stun, "host", &stunServer.host) ||
          !GetStringFromJsonObject(stun, "service", &stunServer.service) ||
          !GetStringFromJsonObject(stun, "protocol", &stunServer.protocol)) {
        LOG(LS_WARNING) << "Failed to parse JSON value: "
                        << value.toStyledString();
        return false;
      }
    } else {
      return false;
    }
  }
  return true;

}
bool GetTurnServer(const Json::Value& value, std::string& turnServer) {
  if (value.type() != Json::objectValue && value.type() != Json::nullValue) {
    LOG(LS_WARNING) << "Failed to parse stun values" ;
    return false;
  }

  Json::Value turn;
  if (GetValueFromJsonObject(value, "turn_service", &turn)) {
    if (turn.type() == Json::objectValue) {
      if (!GetStringFromJsonObject(turn, "host", &turnServer)) {
        LOG(LS_WARNING) << "Failed to parse JSON value: "
                        << value.toStyledString();
        return false;
      }
    } else {
      return false;
    }
  }
  return true;
}

bool GetJSONSignalingMessage(
    const cricket::SessionDescription* sdp,
    const std::vector<cricket::Candidate>& candidates,
    std::string* signaling_message) {
  const cricket::ContentInfo* audio_content = GetFirstAudioContent(sdp);
  const cricket::ContentInfo* video_content = GetFirstVideoContent(sdp);

  std::vector<Json::Value> media;
  if (audio_content) {
    Json::Value value;
    BuildMediaMessage(audio_content, candidates, false, value);
    media.push_back(value);
  }

  if (video_content) {
    Json::Value value;
    BuildMediaMessage(video_content, candidates, true, value);
    media.push_back(value);
  }

  Json::Value signal;
  Append(signal, "media", media);

  // now serialize
  *signaling_message = Serialize(signal);
  return true;
}

bool BuildMediaMessage(
    const cricket::ContentInfo* content_info,
    const std::vector<cricket::Candidate>& candidates,
    bool video,
    Json::Value& params) {

  if (!content_info) {
    return false;
  }

  if (video) {
    Append(params, "label", 2); //always video 2
  } else {
    Append(params, "label", 1); //always audio 1
  }
  std::vector<Json::Value> rtpmap;

  if (!BuildRtpMapParams(content_info, video, rtpmap)) {
    return false;
  }

  Append(params, "rtpmap", rtpmap);

  Json::Value attributes;
//  Append(attributes, "ice-pwd", candidates.front().password());
//  Append(attributes, "ice-ufrag", candidates.front().username());
  std::vector<Json::Value> jcandidates;

  if (!BuildAttributes(candidates, video, jcandidates)) {
    return false;
  }
  Append(attributes, "candidate", jcandidates);
  Append(params, "attributes", attributes);
  return true;
}

bool BuildRtpMapParams(const cricket::ContentInfo* content_info,
                       bool video,
                       std::vector<Json::Value>& rtpmap) {

  if (!video) {
    const cricket::AudioContentDescription* audio_offer =
        static_cast<const cricket::AudioContentDescription*>(
            content_info->description);


    for (std::vector<cricket::AudioCodec>::const_iterator iter =
        audio_offer->codecs().begin();
        iter != audio_offer->codecs().end(); ++iter) {

      Json::Value codec;
      std::string codec_str = std::string("audio/").append(iter->name);
      Append(codec, "codec", codec_str);
      Json::Value codec_id;
      Append(codec_id, talk_base::ToString(iter->id), codec);
      rtpmap.push_back(codec_id);
    }
  } else {
    const cricket::VideoContentDescription* video_offer =
        static_cast<const cricket::VideoContentDescription*>(
            content_info->description);


    for (std::vector<cricket::VideoCodec>::const_iterator iter =
        video_offer->codecs().begin();
        iter != video_offer->codecs().end(); ++iter) {

      Json::Value codec;
      std::string codec_str = std::string("video/").append(iter->name);
      Append(codec, "codec", codec_str);
      Json::Value codec_id;
      Append(codec_id, talk_base::ToString(iter->id), codec);
      rtpmap.push_back(codec_id);
    }
  }
  return true;
}

bool BuildAttributes(const std::vector<cricket::Candidate>& candidates,
                     bool video,
                     std::vector<Json::Value>& jcandidates) {

  for (std::vector<cricket::Candidate>::const_iterator iter =
      candidates.begin(); iter != candidates.end(); ++iter) {
    if ((video && !iter->name().compare("video_rtp") ||
        (!video && !iter->name().compare("rtp")))) {
      Json::Value candidate;
      Append(candidate, "component", kIceComponent);
      Append(candidate, "foundation", kIceFoundation);
      Append(candidate, "generation", iter->generation());
      Append(candidate, "proto", iter->protocol());
      Append(candidate, "priority", iter->preference());
      Append(candidate, "ip", iter->address().IPAsString());
      Append(candidate, "port", iter->address().PortAsString());
      Append(candidate, "type", iter->type());
      Append(candidate, "name", iter->name());
      Append(candidate, "network_name", iter->network_name());
      Append(candidate, "username", iter->username());
      Append(candidate, "password", iter->password());
      jcandidates.push_back(candidate);
    }
  }
  return true;
}

std::string Serialize(const Json::Value& value) {
  Json::StyledWriter writer;
  return writer.write(value);
}

bool Deserialize(const std::string& message, Json::Value& value) {
  Json::Reader reader;
  return reader.parse(message, value);
}


bool ParseJSONSignalingMessage(const std::string& signaling_message,
                               cricket::SessionDescription*& sdp,
                               std::vector<cricket::Candidate>& candidates) {
  ASSERT(!sdp); // expect this to NULL
  // first deserialize message
  Json::Value value;
  if (!Deserialize(signaling_message, value)) {
    return false;
  }

  // get media objects
  std::vector<Json::Value> mlines = ReadValues(value, "media");
  if (mlines.empty()) {
    // no m-lines found
    return false;
  }

  sdp = new cricket::SessionDescription();

  // get codec information
  for (size_t i = 0; i < mlines.size(); ++i) {
    if (mlines[i]["label"].asInt() == 1) {
      cricket::AudioContentDescription* audio_content =
          new cricket::AudioContentDescription();
      ParseAudioCodec(mlines[i], audio_content);
      audio_content->SortCodecs();
      sdp->AddContent(cricket::CN_AUDIO, cricket::NS_JINGLE_RTP, audio_content);
      ParseICECandidates(mlines[i], candidates);

    } else {
      cricket::VideoContentDescription* video_content =
                new cricket::VideoContentDescription();
      ParseVideoCodec(mlines[i], video_content);
      video_content->SortCodecs();
      sdp->AddContent(cricket::CN_VIDEO, cricket::NS_JINGLE_RTP, video_content);
      ParseICECandidates(mlines[i], candidates);
    }
  }
  return true;
}

bool ParseAudioCodec(Json::Value value,
                     cricket::AudioContentDescription* content) {
  std::vector<Json::Value> rtpmap(ReadValues(value, "rtpmap"));
  if (rtpmap.empty())
    return false;

  for (size_t i = 0; i < rtpmap.size(); ++i) {
    cricket::AudioCodec codec;
    std::string pltype = rtpmap[i].begin().memberName();
    talk_base::FromString(pltype, &codec.id);
    Json::Value codec_info = rtpmap[i][pltype];
    std::vector<std::string> tokens;
    talk_base::split(codec_info["codec"].asString(), '/', &tokens);
    codec.name = tokens[1];
    content->AddCodec(codec);
  }

  return true;
}

bool ParseVideoCodec(Json::Value value,
                     cricket::VideoContentDescription* content) {
  std::vector<Json::Value> rtpmap(ReadValues(value, "rtpmap"));
   if (rtpmap.empty())
     return false;

   for (size_t i = 0; i < rtpmap.size(); ++i) {
     cricket::VideoCodec codec;
     std::string pltype = rtpmap[i].begin().memberName();
     talk_base::FromString(pltype, &codec.id);
     Json::Value codec_info = rtpmap[i][pltype];
     std::vector<std::string> tokens;
     talk_base::split(codec_info["codec"].asString(), '/', &tokens);
     codec.name = tokens[1];
     content->AddCodec(codec);
   }
   return true;
}

bool ParseICECandidates(Json::Value& value,
                        std::vector<cricket::Candidate>& candidates) {
  Json::Value attributes = ReadValue(value, "attributes");
  std::string ice_pwd = ReadString(attributes, "ice-pwd");
  std::string ice_ufrag = ReadString(attributes, "ice-ufrag");

  std::vector<Json::Value> jcandidates = ReadValues(attributes, "candidate");
  char buffer[64];
  for (size_t i = 0; i < jcandidates.size(); ++i) {
    cricket::Candidate cand;
    std::string str;
    str = ReadUInt(jcandidates[i], "generation");
    cand.set_generation_str(str);
    str = ReadString(jcandidates[i], "proto");
    cand.set_protocol(str);
    double priority = ReadDouble(jcandidates[i], "priority");
#ifdef _DEBUG
    double as_int = static_cast<int>(priority);
    ASSERT(as_int == priority);
#endif
    sprintf(buffer, "%i", static_cast<int>(priority));
    str = buffer;
    cand.set_preference_str(str);
    talk_base::SocketAddress addr;
    str = ReadString(jcandidates[i], "ip");
    addr.SetIP(str);
    str = ReadString(jcandidates[i], "port");
    int port; talk_base::FromString(str, &port);
    addr.SetPort(port);
    cand.set_address(addr);
    str = ReadString(jcandidates[i], "type");
    cand.set_type(str);
    str = ReadString(jcandidates[i], "name");
    cand.set_name(str);
    str = ReadString(jcandidates[i], "network_name");
    cand.set_network_name(str);
    str = ReadString(jcandidates[i], "username");
    cand.set_username(str);
    str = ReadString(jcandidates[i], "password");
    cand.set_password(str);
    candidates.push_back(cand);
  }
  return true;
}

std::vector<Json::Value> ReadValues(
    Json::Value& value, const std::string& key) {
  std::vector<Json::Value> objects;
  for (size_t i = 0; i < value[key].size(); ++i) {
    objects.push_back(value[key][i]);
  }
  return objects;
}

Json::Value ReadValue(Json::Value& value, const std::string& key) {
  return value[key];
}

std::string ReadString(Json::Value& value, const std::string& key) {
  return value[key].asString();
}

uint32 ReadUInt(Json::Value& value, const std::string& key) {
  return value[key].asUInt();
}

double ReadDouble(Json::Value& value, const std::string& key) {
  return value[key].asDouble();
}

// Add values
void Append(Json::Value& object, const std::string& key, bool value) {
  object[key] = Json::Value(value);
}

void Append(Json::Value& object, const std::string& key, char * value) {
  object[key] = Json::Value(value);
}
void Append(Json::Value& object, const std::string& key, double value) {
  object[key] = Json::Value(value);
}
void Append(Json::Value& object, const std::string& key, float value) {
  object[key] = Json::Value(value);
}
void Append(Json::Value& object, const std::string& key, int value) {
  object[key] = Json::Value(value);
}
void Append(Json::Value& object, const std::string& key, std::string value) {
  object[key] = Json::Value(value);
}
void Append(Json::Value& object, const std::string& key, uint32 value) {
  object[key] = Json::Value(value);
}

void Append(Json::Value& object, const std::string& key, Json::Value value) {
  object[key] = value;
}

void Append(Json::Value & object,
            const std::string & key,
            std::vector<Json::Value>& values){
  for (std::vector<Json::Value>::const_iterator iter = values.begin();
      iter != values.end(); ++iter) {
    object[key].append(*iter);
  }
}

} //namespace webrtc