//
// Created by parth on 2/4/2019.
//

#include <audio/include/AudioEngine.h>
#include <utility>
#include "Singleton.h"
#include "KPApi.h"


Singleton* Singleton::_instance1 = nullptr;
std::string Singleton::userToken;
std::string Singleton::firebaseToken;
std::string Singleton::clubIDString;
int Singleton::clubID = 0;
int Singleton::role = 1;
int Singleton::playerID = 0;
int Singleton::classType = 0;
cocos2d::Sprite *Singleton::profilePic;
int Singleton::productID = 0;
struct structClubTableData Singleton::clubTableData = {.product_id = 0, .club_id = -1, .tableType = 0, .rangeStart = 0};
bool Singleton::isAudioMute = false;
bool Singleton::isTitleScene = false;
bool Singleton::isGameScene = false;

Singleton::Singleton() = default;

Singleton* Singleton::getInstance()
{
    if(!_instance1)
        _instance1 = new Singleton();
    return _instance1;
}
//////////  USER TOKEN //////////////
void Singleton::setUserToken(std::string userTokenToSet){

    userToken = std::move(userTokenToSet);
}
std::string Singleton::getUserToken(){

    return userToken;
}

//////////  FIREBASE TOKEN //////////////
void Singleton::setFireBaseToken(std::string firebaseTokenToSet){

    firebaseToken = std::move(firebaseTokenToSet);
}

std::string Singleton::getFireBaseToken(){

    return firebaseToken;
}


///////  CLUB ID //////
void Singleton::setClubID(int clubIDToSet){

    clubID =  clubIDToSet;
}
int Singleton::getClubID() {

    return clubID;
}
///.........  ROLE ......///////////
void Singleton::setRole(int roleToSet){

    role =  roleToSet;
}
int Singleton::getRole(){

    return role;
}
//...... club ID string....////
void Singleton::setClubIDString(std::string clubIDStringToSet){

    clubIDString = std::move(clubIDStringToSet);
}
std::string Singleton::getClubIDString(){

    return clubIDString;
}
//..........  PLAYER ID ....//
void Singleton::setPlayerID(int playerIDToSet){

    playerID =  playerIDToSet;
}
int Singleton::getPlayerID(){

    return playerID;
}
std::string Singleton::getPlaterIDString(){

    return std::to_string(playerID);
}
void Singleton::setProfilePic(cocos2d::Sprite *profilePictureToSet){

    profilePic = profilePictureToSet;
}
cocos2d::Sprite* Singleton::getProfilePic(){

    return profilePic;
}

std::string Singleton::getCountryName(){
    
#if CC_TARGET_PLATFORM == CC_PLATFORM_IOS
    
    return ObjCCall::carrierCountry(); 
    
#elif CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID


    cocos2d::JniMethodInfo methodInfo;
    if (cocos2d::JniHelper::getStaticMethodInfo(methodInfo, "org/cocos2dx/cpp/AppActivity", "getUserCountry", "()Ljava/lang/String;")) {

        std::string fileName;
        auto jstr = (jstring) methodInfo.env->CallStaticObjectMethod(methodInfo.classID, methodInfo.methodID);
        fileName = cocos2d::JniHelper::jstring2string(jstr);
        methodInfo.env->DeleteLocalRef(methodInfo.classID);

        if(!fileName.empty()){
            return fileName;
        }

    }


    
#else
    
#endif

    return "No country Found";

}

bool Singleton::makePayment(int productID, cocos2d::Node *node){

#if CC_TARGET_PLATFORM == CC_PLATFORM_IOS

#elif CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID

    cocos2d::JniMethodInfo methodInfo;
    if (cocos2d::JniHelper::getStaticMethodInfo(methodInfo, "org/cocos2dx/cpp/AppActivity", "stripPayment", "(Ljava/lang/String;Ljava/lang/String;I)V")) {

        jint NJIproductID = productID;
        jstring urlForUploadFile = methodInfo.env->NewStringUTF(paymentURL);
        jstring userTokenJstr = methodInfo.env->NewStringUTF(Singleton::getInstance()->getUserToken().c_str());
        methodInfo.env->CallStaticVoidMethod(methodInfo.classID, methodInfo.methodID, urlForUploadFile, userTokenJstr, NJIproductID);
        methodInfo.env->DeleteLocalRef(methodInfo.classID);
        return true;
    }
    
#else
    

#endif
    
    cocos2d::log("upload Image JNI method not found\n");
    
    return false;

}


bool Singleton::checkNeworkConnectivity(){

#if CC_TARGET_PLATFORM == CC_PLATFORM_IOS

    return ObjCCall::isNetworkAvilable();
    
#elif CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID

    cocos2d::JniMethodInfo methodInfo;
    if (cocos2d::JniHelper::getStaticMethodInfo(methodInfo, "org/cocos2dx/cpp/AppActivity", "isInternetAvailable", "()Z")) {

        jboolean result = methodInfo.env->CallStaticBooleanMethod(methodInfo.classID, methodInfo.methodID);
        methodInfo.env->DeleteLocalRef(methodInfo.classID);

        return result;

    }else{

        cocos2d::log("upload Image JNI method not found\n");
       
    }
#else

#endif
    
     return false;

}


void Singleton::setProductID(int productIDToSet){

    productID =  productIDToSet;

}
int Singleton::getProductID(){

    return productID;
}

std::string Singleton::convertFloatIntoKilloAndMil(float value){

    if(value >= 1000.0f && value < 1000000.0f){

        value = (value / 1000);

        if(value > 99){

            return cocos2d::StringUtils::format("%2.0f K",value);
        }

        return cocos2d::StringUtils::format("%2.2f K",value);

    }else if(value >= 1000000.0f){

        value = (value / 1000000);

        return cocos2d::StringUtils::format("%2.2f M",value);

    }else{

        return cocos2d::StringUtils::format("%3.f",value);

    }

}

void Singleton::setclubtableData( int product_id, int club_id, int tableType, int rangeStart){

    clubTableData.product_id = product_id;
    clubTableData.club_id = club_id;
    clubTableData.tableType = tableType;
    clubTableData.rangeStart = rangeStart;
}

struct structClubTableData Singleton::getclubtableData(){

    return clubTableData;
}

void Singleton::DatePlusDays( struct tm* date, int days )
{
    const time_t ONE_DAY = 24 * 60 * 60 ;

    // Seconds since start of epoch
    time_t date_seconds = (mktime( date ) + (days * ONE_DAY)) ;

    // Update caller's date
    // Use localtime because mktime converts to UTC so may change date
    *date = *localtime( &date_seconds ) ;
}

void Singleton::setAudioIsMute(bool isMute) {


    isAudioMute = isMute;

    cocos2d::UserDefault::getInstance()->setBoolForKey("isAudioMute", isAudioMute);

}

void Singleton::setTitleScene(bool setTitleScene) {

    isTitleScene = setTitleScene;

}

bool Singleton::getTitleScene(){

    return isTitleScene;
}

void Singleton::setClassType(int setClassType) {

    classType = setClassType;

}

int Singleton::getClassType(){

    return classType;
}

int Singleton::getNetworkStrength() {

#if CC_TARGET_PLATFORM == CC_PLATFORM_IOS

    return ObjCCall::isNetworkAvilable();

#elif CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID

    auto timeStart = std::chrono::high_resolution_clock::now();
// do something... wait for result...
    auto timeEnd = std::chrono::high_resolution_clock::now();

    long long duration = std::chrono::duration_cast<std::chrono::microseconds>(timeEnd - timeStart).count();

    /*cocos2d::JniMethodInfo methodInfo;
    if (cocos2d::JniHelper::getStaticMethodInfo(methodInfo, "org/cocos2dx/cpp/AppActivity", "netWorkStrengt", "()I")) {

        jint result = methodInfo.env->CallStaticIntMethod(methodInfo.classID, methodInfo.methodID);
        methodInfo.env->DeleteLocalRef(methodInfo.classID);

        return result;

    }else{

        cocos2d::log("netWorkStrengt JNI method not found\n");

    }*/
#else

#endif

    return 0;


}

int maxLine = 80;
typedef std::list<std::string> WordList;
const int pageWidth = 40;
std::string mainString;
std::vector<std::string> strings;


WordList Singleton::splitTextIntoWords( const std::string &text )
{
    WordList words;
    std::istringstream in(text);
    std::copy(std::istream_iterator<std::string>(in),
              std::istream_iterator<std::string>(),
              std::back_inserter(words));
    return words;
}

/*void Singleton::padAfterPunctuation(std::string &input)
{
    const std::string punct = ".,?;!";

    for (char p : punct)
// for(size_t i = 0; i < punct,size(); ++i) if you can't use a range based for loop.
// use punct[i] rather than p in find below as well.
    {
        size_t pos = 0;
        while ((pos = input.find(p, pos)) != std::string::npos && input.size() < maxLine)
        {
            input.insert(++pos, " ");
        }
    }
}

void Singleton::padRandomAfterSpace(std::string &input)
{
    srand(time(0));

    size_t pos = 0;
    while (input.size() < maxLine)
    {
        pos = input.find(' ', pos);
        if (pos < input.size() && pos != std::string::npos)
        {
            if (rand() & 1)
            {
                input.insert(pos, " ");
            }
            pos = input.find_first_not_of(' ', pos);
        }
        else
        {
            pos = 0;
        }
    }
}*/

void Singleton::split(const std::string& s, char c, std::vector<std::string>& v){

    std::string::size_type i = 0;
    std::string::size_type j = s.find(c);
    while (j != std::string::npos) {
        v.push_back(s.substr(i, j-i));
        i = ++j;
        j = s.find(c, j);
        if (j == std::string::npos)
            v.push_back(s.substr(i, s.length()));
    }
}

/*std::string Singleton::justyfyString(std::string inputString, int maxLengthUser){

//    srand(time(0));

//    ifstream fin("unjustified.txt");
//    ofstream fout("justified.txt");

    cocos2d::log("message : %s", inputString.c_str());

    maxLine = maxLengthUser;

    std::vector<std::string> seglist;

    Singleton::getInstance()->split(inputString, '\n', seglist);

    std::string inputLine;

    for(int i = 0 ; i < inputString.size() ; i++){


        if (  inputString.size() > 70 ) {

            inputLine.insert( inputString.rfind( ' ' ),std::string(  maxLine - inputString.size() ,' ' ) );
//            std::cout << line << '\n';

        } else {
//            std::cout << line << '\n';
        }

        *//*if( line.size() == maxLine ){

            std::cout << line << '\n';

        } else if (  line.size() > 70 ) {

            line.insert( line.rfind( ' ' ),std::string(  max_size - line.size() ,' ' ) );
            std::cout << line << '\n';

        } else {
            std::cout << line << '\n';
        }*//*

    }


*//*
    for(int i = 0 ; i < seglist.size() ; i++){



        if (seglist[i].size() > 40 && seglist[i].size() < maxLine)
        {
            Singleton::getInstance()->padAfterPunctuation(seglist[i]);
            if (seglist[i].size() < maxLine)
            {
                Singleton::getInstance()->padRandomAfterSpace(seglist[i]);
            }
        }

        cocos2d::log("message : %s", seglist[i].c_str());

        inputLine = inputLine + seglist[i];


    }
*//*
    return inputLine;

  *//*  while (getline(inputString, inputLine))
    {

        fout << inputLine << endl;
    }*//*

}*/

void Singleton::justifyLine( std::string line )
{
    size_t pos = line.find_first_of(' ');
    if (pos != std::string::npos) {
        while (line.size() < pageWidth) {
            pos = line.find_first_not_of(' ', pos);
            line.insert(pos, " ");
            pos = line.find_first_of(' ', pos+1);
            if (pos == std::string::npos) {
                pos = line.find_first_of(' ');
            }
        }
    }
//    std::cout << line << std::endl;
    mainString = mainString + line + '\n';
    strings.push_back(line);
    cocos2d::log("output : %s", line.c_str());

}

std::string Singleton::justifyText( const std::string &text )
{
    WordList words = splitTextIntoWords(text);

    std::string line;
    for (const std::string& word : words) {
        if (line.size() + word.size() + 1 > pageWidth) { // next word doesn't fit into the line.
            justifyLine(line);
            line.clear();
            line = word;
        } else {
            if (!line.empty()) {
                line.append(" ");
            }
            line.append(word);
        }
    }
//    std::cout << line << std::endl;
    cocos2d::log("output here: %s", line.c_str());
    mainString = mainString + line;
    strings.push_back(line);

    cocos2d::log("output here: %s", mainString.c_str());

    return mainString;
}