#include "WifiUtil.h"

#include <stdlib.h>
#include <unistd.h>
#include <thread>


typedef std::list<std::string> LIST_STRING;
typedef std::list<WifiInfo*> LIST_WIFIINFO;
static int network_id;

static const char *WIFI_CONFIG_FORMAT = "ctrl_interface=/var/run/wpa_supplicant\n"
                                "ap_scan=1\n\nnetwork={\nssid=\"%s\"\n"
                                "psk=\"%s\"\npriority=1\n}\n";

void execute(const char cmdline[],char recv_buff[]){
    log_info("consule_run: %s\n",cmdline);
    FILE *stream = NULL;
    char buff[1024];

    memset(recv_buff, 0, strlen(recv_buff));
    if((stream = popen(cmdline,"r"))!=NULL){
        while(fgets(buff,1024,stream)){
            strcat(recv_buff,buff);
        }
    }
    pclose(stream);
}

int get_pid(const char Name[]) {
    int len;
    char name[20] = {0};
    len = strlen(Name);
    strncpy(name,Name,len);
    name[len] ='\0';
    char cmdresult[256] = {0};
    char cmd[20] = {0};
    FILE *pFile = NULL;
    int  pid = 0;

    sprintf(cmd, "pidof %s", name);
    pFile = popen(cmd, "r");
    if (pFile != NULL)  {
        while (fgets(cmdresult, sizeof(cmdresult), pFile)) {
            pid = atoi(cmdresult);
            break;
        }
    }
    pclose(pFile);
    return pid;
}

/**
 * split buff array by '\n' into string list.
 * @parm buff[]
 */
LIST_STRING charArrayToList(char buff[]){
    LIST_STRING stringList;
    std::string item;
    for(int i=0;i<strlen(buff);i++){
        if(buff[i] != '\n'){
            item += buff[i];
        } else {
            stringList.push_back(item);
            item.clear();
        }
    }
    return stringList;
}

/**
 * format string list into wifiInfo list by specific rules
 * @parm string_list
 * @return LIST_WIFIINFO
 */
LIST_WIFIINFO wifiStringFormat(LIST_STRING string_list){
    LIST_WIFIINFO wifiInfo_list;

    LIST_STRING::iterator stringIte;

    /* delete first useless item */
    string_list.pop_front();

    for(stringIte=string_list.begin();stringIte!=string_list.end();stringIte++){
        WifiInfo *wifiInfoItem = new WifiInfo();
        std::string wifiStringItem = *stringIte;

        /* use for set wifiInfo item:bssid ssid etc*/
        std::string tempString;
        int index = 0; /* temp index,flag '\t' appear count*/

        for(int i=0;i<wifiStringItem.size();i++){
            if(wifiStringItem.at(i)!='\t' && i != (wifiStringItem.size()-1)){
                tempString += wifiStringItem.at(i);
            } else {
                switch(index){
                case 0: //bssid
                    wifiInfoItem->setBssid(tempString);
                    break;
                case 1: //frequency
                    wifiInfoItem->setFrequency(tempString);
                    break;
                case 2: //signalLevel
                    wifiInfoItem->setSignalLevel(tempString);
                    break;
                case 3: //flags
                    wifiInfoItem->setFlags(tempString);
                    break;
                case 4: //ssid
                    tempString += wifiStringItem.at(i);
                    wifiInfoItem->setSsid(tempString);
                    break;
                default:
                    break;
                }
                index ++;
                tempString.clear();
            }
        }
        wifiInfo_list.push_back(wifiInfoItem);
    }
    return wifiInfo_list;
}

/**
 * parse wifi info list into json string.
 * @parm wifiInfoList
 * @return json string
 */
std::string parseIntoJson(LIST_WIFIINFO wifiInfoList){
    LIST_WIFIINFO::iterator iterator;

    rapidjson::Document document;
    document.SetObject();
    rapidjson::Document::AllocatorType& allocator = document.GetAllocator();

    /* 1. add return type */
    document.AddMember("type","WifiList",allocator);
    /* 2. add reutn content */
    rapidjson::Value wifiArrayValue(rapidjson::kArrayType);
    for(iterator = wifiInfoList.begin(); iterator != wifiInfoList.end(); ++iterator){
        (*iterator)->addJsonToRoot(document,wifiArrayValue);
    }
    document.AddMember("content",wifiArrayValue,allocator);

    /* parse into string */
    rapidjson::StringBuffer buffer;
    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
    document.Accept(writer);

    return buffer.GetString();
}

/**
 * get json substr from http respose head.
 * split by '{' and "}"
 * @parm message http.
 */
std::string getJsonFromMessage(char message[]){
    std::string str(message);
    return str.substr(str.find('{'));
}

/**
 * use wpa_cli tool to connnect wifi in alexa device
 * @parm ssid
 * @parm password
 */
bool wifiConnect(std::string ssid,std::string password){
    char ret_buff[MSG_BUFF_LEN] = {0};
    char cmdline[MSG_BUFF_LEN] = {0};
    int id = -1;
    bool execute_result = false;

    // 1. add network
    execute("wpa_cli -iwlan0 add_network",ret_buff);
    id = atoi(ret_buff);
    if(id < 0){
        log_err("add_network failed.\n");
        return false;
    }
    // 2. setNetWorkSSID
    memset(cmdline, 0, sizeof(cmdline));
    sprintf(cmdline,"wpa_cli -iwlan0 set_network %d ssid \\\"%s\\\"",id, ssid.c_str());
    printf("%s\n", cmdline);
    execute(cmdline,ret_buff);
    execute_result = !strncmp(ret_buff,"OK",2);
    if(!execute_result){
        log_err("setNetWorkSSID failed.\n");
        return false;
    }
    // 3. setNetWorkPWD
    memset(cmdline, 0, sizeof(cmdline));
    sprintf(cmdline,"wpa_cli -iwlan0 set_network %d psk \\\"%s\\\"", id,password.c_str());
    printf("%s\n", cmdline);
    execute(cmdline,ret_buff);
    execute_result = !strncmp(ret_buff,"OK",2);
    if(!execute_result){
        log_err("setNetWorkPWD failed.\n");
        return false;
    }
    // 4. selectNetWork
    memset(cmdline, 0, sizeof(cmdline));
    sprintf(cmdline,"wpa_cli -iwlan0 select_network %d", id);
    printf("%s\n", cmdline);
    execute(cmdline,ret_buff);
    execute_result = !strncmp(ret_buff,"OK",2);
    if(!execute_result){
        log_err("setNetWorkPWD failed.\n");
        return false;
    }

    return true;
}

bool checkWifiIsConnected(){
    char ret_buff[MSG_BUFF_LEN] = {0};
    char cmdline[MSG_BUFF_LEN] = {0};

    LIST_STRING stateSList;
    LIST_STRING::iterator iterator;   

    // udhcpc network
    int udhcpc_pid = get_pid("udhcpc");
    if(udhcpc_pid != 0){
        memset(cmdline, 0, sizeof(cmdline));
        sprintf(cmdline,"kill %d",udhcpc_pid);
        execute(cmdline,ret_buff);
    }
    execute("udhcpc -n -t 10 -i wlan0",ret_buff);

    bool isWifiConnected = false;
    int match = 0;
    /* 15s to check wifi whether connected */
    for(int i=0;i<5;i++){
        sleep(2);
        match = 0;
        execute("wpa_cli -iwlan0 status",ret_buff);
        stateSList = charArrayToList(ret_buff);
        for(iterator=stateSList.begin();iterator!=stateSList.end();iterator++){
            std::string item = (*iterator);
            if(item.find("wpa_state")!=std::string::npos){
                if(item.substr(item.find('=')+1)=="COMPLETED"){
                    match++;
                }
            }
            if(item.find("ip_address")!=std::string::npos){
                if(item.substr(item.find('=')+1)!="127.0.0.1"){
                    match++;
                }
            }
        }
        if(match >= 2){
            isWifiConnected = true;
            // TODO play audio: wifi connected
            log_info("Congratulation: wifi connected.\n");
            break;
        }
        log_info("Check wifi state with none state. try more %d/5, \n",i+1);
    }

    if(!isWifiConnected){
        // TODO play audio: wifi failed.
        log_info("wifi connect failed.please check enviroment.\n");
        system("gst-play-1.0 -q --no-interactive /usr/ap_notification/wifi_connect_failed.mp3 &");
 
    } else {
        system("gst-play-1.0 -q --no-interactive /usr/ap_notification/wifi_conneted.mp3 &");
        system("softapServer stop &");
    }
}


std::string WifiUtil::getWifiListJson(){
    char ret_buff[MSG_BUFF_LEN] = {0};
    std::string ret;
    int retry_count = 10;

    LIST_STRING wifiStringList;
    LIST_WIFIINFO wifiInfoList;

retry:
    execute("wpa_cli -i wlan0 -p /var/run/wpa_supplicant scan", ret_buff);
    /* wap_cli sacn is useable */
    if(!strncmp(ret_buff,"OK",2)){
        log_info("scan useable: OKOK\n");
        execute("wpa_cli -i wlan0 -p /var/run/wpa_supplicant scan_r", ret_buff);
        wifiStringList = charArrayToList(ret_buff);
        wifiInfoList = wifiStringFormat(wifiStringList);
    }
    
    if ((wifiInfoList.size() == 0)  && (--retry_count > 0)) {
	usleep(500000);
        goto retry;
    }
    // parse wifiInfo list into json.
    ret = parseIntoJson(wifiInfoList);
    log_info("list size: %d\n",wifiInfoList.size());
    return ret;
}

std::string WifiUtil::getDeviceContextJson() {
    std::string ret = " ";
    std::string sn1;
    std::string sn2;
    std::string sn3;
    std::string sn4;

#define SN_1 "ro.hisense.jhkdeviceid"
#define SN_2 "ro.hisense.jhldeviceid"
#define SN_3 "ro.hisense.wifiid"
#define SN_4 "ro.hisense.uuid"

    rapidjson::Document newDoc;
    FILE *myFile = fopen(DEVICE_CONFIG_FILE, "r");
    if (!myFile) {
        log_info("%s, %s not exist\n", __func__, DEVICE_CONFIG_FILE);
        return ret;
    }
    char readBuffer[65536];
    rapidjson::FileReadStream is(myFile, readBuffer, sizeof(readBuffer));
    newDoc.ParseStream<0>(is);
    fclose(myFile);

    if (newDoc.HasParseError()) {
        log_info("Json Parse error: %d\n", newDoc.GetParseError());
        return ret;
    }
    if (newDoc.HasMember(SN_1)) {
         sn1 = newDoc[SN_1].GetString();
    }
    if (newDoc.HasMember(SN_2)) {
         sn2 = newDoc[SN_2].GetString();
    }
    if (newDoc.HasMember(SN_3)) {
         sn3 = newDoc[SN_3].GetString();
    }
    if (newDoc.HasMember(SN_4)) {
         sn4 = newDoc[SN_4].GetString();
    }
    log_info("Json Parse : %s, %s, %s, %s\n", sn1.c_str(), sn2.c_str(), sn3.c_str(), sn4.c_str());

    rapidjson::Document document;
    document.SetObject();
    rapidjson::Document::AllocatorType& allocator = document.GetAllocator();

    /* 1. add return type */
    document.AddMember("type","DeviceContext",allocator);
    /* 2. add reutn content */
    rapidjson::Value snObj(rapidjson::kObjectType);
    snObj.AddMember(SN_1, rapidjson::StringRef(sn1.c_str()), allocator);
    snObj.AddMember(SN_2, rapidjson::StringRef(sn2.c_str()), allocator);
    snObj.AddMember(SN_3, rapidjson::StringRef(sn3.c_str()), allocator);
    snObj.AddMember(SN_4, rapidjson::StringRef(sn4.c_str()), allocator);
    document.AddMember("content",snObj,allocator);
    /* parse into string */
    rapidjson::StringBuffer buffer;
    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
    document.Accept(writer);

    return buffer.GetString();
}

static bool saveWifiConfig(const char* name, const char* pwd)
{
    FILE *fp;
    char body[WIFI_CONFIG_MAX];
    int fd;
    fp = fopen("/data/cfg/wpa_supplicant.conf", "w");

    if (fp == NULL)
    {
        return -1;
    }

    snprintf(body, sizeof(body), WIFI_CONFIG_FORMAT, name, pwd);
    fputs(body, fp);
    fflush(fp);
    fd = fileno(fp);
    if (fd >= 0) {
        fsync(fd);
        printf("save wpa_supplicant.conf sucecees.\n");
    }
    fclose(fp);

    return 0;
}


void WifiUtil::WifiSetUp(char recv_buff[]){
    std::string jsonString = getJsonFromMessage(recv_buff);

    /* get setUp user name and password */
    rapidjson::Document document;
    if (document.Parse(jsonString.c_str()).HasParseError()) {
        log_err("parseJsonFailed \n");
        return;
    }

    std::string userName;
    std::string password;

    auto userNameIterator = document.FindMember("ssid");
    if (userNameIterator != document.MemberEnd() && userNameIterator->value.IsString()) {
       	userName = userNameIterator->value.GetString();
    }

    auto passwordIterator = document.FindMember("pwd");
    if (passwordIterator != document.MemberEnd() && passwordIterator->value.IsString()) {
        password = passwordIterator->value.GetString();
    }

    if(userName.empty()||password.empty()){
        log_err("userName or password empty. \n");
        return;
    }

    /* use wpa_cli to connect wifi by ssid and password */
    bool connectResult = wifiConnect(userName,password);

    if(connectResult){
        std::thread thread(checkWifiIsConnected);
        thread.detach();

        saveWifiConfig(userName.c_str(), password.c_str());
    }else{
        log_info("wifi connect failed.please check enviroment. \n");
        // TODO play audio: wifi connect failed.
    }
    return;
}