#include "Core.hpp"
namespace App
{
string Core::_relayAddressPortStr = "None";
string Core::_peerTagStr = "None";
string Core::_encryptionKeyStr = "None";
string Core::_audioDeviceSource = "None";
string Core::_audioDeviceSink = "None";
string Core::_configJsonPath = "None";
string Core::_peerRoleStr = "None";
VoIPController *Core::_pVoipController = nullptr;
Core::Core()
{

}
Core::~Core()
{
}
string Core::getInputParsedArg(po::variables_map &vm, const char *key){
        if (vm.count(key) == 1) {
            return vm[key].as<string>();
        }
        else{
            throw std::invalid_argument(key);
        }
}

int Core::parseProgramOptions(int ac, char* av[])
{
// -k encryption_key_hex -i /path/to/sound_A.ogg -o /path/to/sound_output_B.ogg -c config.json -r caller
    try {
        po::options_description desc("Allowed options");
        desc.add_options()
            ("address", po::value<string>(), "reflector:port")
            ("tag", po::value<string>(), "caller/callee tag_hex")
            ("key,k", po::value<string>(), "encryption key_hex")
            ("input,i", po::value<string>(), "input audio device (source) ex: callmic")
            ("output,o", po::value<string>(), "output audio device (sink) ex: callout")
            ("config,c", po::value<string>(), "config.json")
            ("role,r", po::value<string>(), "caller/callee")
        ;
        po::positional_options_description p;
        p.add("address", 1);
        p.add("tag", 1);

        po::variables_map vm;
        po::store(po::command_line_parser(ac, av).options(desc).positional(p).run(), vm);
        po::notify(vm);

        //TODO: use validation wrapper
        _relayAddressPortStr = getInputParsedArg(vm,"address");
        _peerTagStr = getInputParsedArg(vm,"tag");
        _encryptionKeyStr = getInputParsedArg(vm,"key");
        _audioDeviceSource = getInputParsedArg(vm,"input");
        _audioDeviceSink = getInputParsedArg(vm,"output");
        _configJsonPath = getInputParsedArg(vm,"config");
        _peerRoleStr = getInputParsedArg(vm,"role");
        if((_peerRoleStr != "callee") && (_peerRoleStr != "caller"))
        {
            throw invalid_argument("Incorrect peer role, expected \"callee\" or \"caller\"");
        }
        cout << "parsed args:\n"
        << _relayAddressPortStr << endl
        << _peerTagStr << endl
        << _encryptionKeyStr << endl
        << _audioDeviceSource << endl
        << _audioDeviceSink << endl
        << _configJsonPath << endl
        << _peerRoleStr << endl;
    }
    catch(exception& e) {
        cerr << "error: " << e.what() << endl;
        return 1;
    }
    catch(...) {
        cerr << "Exception of unknown type!\n";
        return 1;
    }

    return 0;
}
void Core::convertHexStringToByteArray(const string str, unsigned char bytearray[])
{
    stringstream converter;
    for (int i = 0; i < str.length(); i += 2)
    {
        converter << std::hex << str.substr(i, 2);
        int byte;
        converter >> byte;
        bytearray[i / 2] = byte & 0xFF;
        converter.str(std::string());
        converter.clear();
    }
}
void Core::updateConfig(const string &data)
{
    ServerConfig::GetSharedInstance()->Update(data);
}
bool Core::getConfigFlag(const string name)
{
    return ServerConfig::GetSharedInstance()->GetBoolean(name, false);
}
Core::State Core::getState(void)
{
    return static_cast<Core::State>(_pVoipController->GetConnectionState());
}
void Core::stopCall(void)
{
    _pVoipController->Stop();
}
string Core::getStatistics(void)
{
    return _pVoipController->GetDebugLog();
}
void Core::startCall(void)
{
    if(_pVoipController == nullptr)
    {
        _pVoipController = new VoIPController();
    };
    ifstream t(_configJsonPath);
    string jsonString((std::istreambuf_iterator<char>(t)),std::istreambuf_iterator<char>());
    updateConfig(jsonString);
    const bool isUseTCP = getConfigFlag("use_tcp");
    const bool isForceTCP = getConfigFlag("force_tcp");
    const Endpoint::Type endpointType = isUseTCP || isForceTCP ? Endpoint::Type::TCP_RELAY : Endpoint::Type::UDP_RELAY;
    const int32_t CallConnectTimeoutMs = 30000;
    const int32_t CallPacketTimeoutMs = 10000;
    cout << endpointType;
    VoIPController::Config config;

    const bool isOutgoing = _peerRoleStr == "caller" ? true : false;
    std::vector<string> resTemp;
    boost::split(resTemp, _relayAddressPortStr, [](char c){return c == ':';});
    std::string relayAddressStr = std::string(resTemp.at(0));
    uint16_t relayPortInt = std::stoi(resTemp.at(1));

    IPv4Address relayAddressIPv4(relayAddressStr);
    uint32_t u32Ipv4 = relayAddressIPv4.GetAddress();
    int64_t endpointId = (static_cast<int64_t>(relayPortInt) << 32) | (static_cast<int64_t>(u32Ipv4));
    cout << relayAddressStr << ':' << relayPortInt << endl;
    cout << endpointId << endl;
    IPv6Address relayAddressIPv6("0:0:0:0:0:0");
    unsigned char peerTagByteArray[16], authKeyByteArray[256];
    convertHexStringToByteArray(_peerTagStr, peerTagByteArray);
    convertHexStringToByteArray(_encryptionKeyStr, authKeyByteArray);
    //TODO refactor
    Endpoint endpoint(endpointId, relayPortInt, relayAddressIPv4, relayAddressIPv6, endpointType, peerTagByteArray);
    auto endpoints = vector<Endpoint>();
    endpoints.emplace_back(endpoint);
    _pVoipController->SetRemoteEndpoints(endpoints, false, _pVoipController->GetConnectionMaxLayer());
    config.dataSaving = DATA_SAVING_NEVER;
    config.enableAEC = false;
    config.enableNS = true;
    config.enableAGC = true;
    config.enableVolumeControl = true;
    config.initTimeout = CallConnectTimeoutMs / 1000.0f;
    config.recvTimeout = CallPacketTimeoutMs / 1000.0f;
    auto callbacks = VoIPController::Callbacks();
    _pVoipController->SetConfig(config);
    _pVoipController->SetCurrentAudioOutput(_audioDeviceSink);
    _pVoipController->SetCurrentAudioInput(_audioDeviceSource);
    _pVoipController->SetOutputVolume(100 / 100.0f);
    _pVoipController->SetInputVolume(100 / 100.0f);
    _pVoipController->SetEncryptionKey(reinterpret_cast<char *>(authKeyByteArray), isOutgoing);
    _pVoipController->SetMicMute(false);
    _pVoipController->SetNetworkType(NET_TYPE_UNKNOWN);
    _pVoipController->SetCallbacks(callbacks);
    _pVoipController->Start();
    _pVoipController->Connect();
}
}//namespace App