'use strict'

import { ipcRenderer } from 'electron';
import { io, ios, app } from './app';
import { clearCache, upload, pythonupload, pythonuploadfile, pythonreset, getmcnty, pythoncmd, sendcontent, uploadfile } from './uploader';
import errHandler from './error_handle';
import SerialPort from 'serialport';

//var request = require('request');
//var querystring = require('querystring');

/* ************ Functions ************ */

/**
 * Send boards list back to front-side by websocket.
 * @param {string} e Event
 * @param {object} list Object of boards list
 * @returns {void} void
 */
function resultList(e, list) {
    io.sockets.emit('list', { List: list });
    ios.sockets.emit('list', { List: list });
    // var _l = {};
    // var i = 0, j = 0;
    // _l["CocoRoboX"] = [];
    // for (var i = 0; i < list.boards.length; i++) {
    //     _l["CocoRoboX"].push({
    //         "Port": (list.boards[i].comName || list.boards[i].path),
    //         "Status": 1
    //     })
    // }
    // for (var j = 0; j < list.wifi.length; j++) {
    //     _l["CocoRoboX"].push({
    //         "Port": (list.wifi[j].comName || list.wifi[j].path),
    //         "Status": 1
    //     })
    // }
    // netRequest('/plugin/status', { "PluginID": "CocoRoboX", "HardwareStatus": _l })
    return;
}

function getSocketBySid(sid) {
    let socket = io.sockets.connected[sid];
    socket ? '' : socket = ios.sockets.connected[sid];
    return socket;
}

/**
 * Output error if socket id was invalid.
 * @returns {void} void
 */
function sidInvalid() {
    console.error('Socket id was invalid.');
    return;
}

/**
 * Output error if socket was not found.
 * @returns {void} void
 */
function sidNotFound() {
    console.error('Socket was not found.');
    return;
}

/**
 * Send resutl of open command back to front-side by websocket.
 * @param {string} e Event
 * @param {string} sid Socket's id
 * @param {string} comName Communicated port name
 * @param {number} baud Baud-rate
 * @returns {void} void
 */
function resultOpen(e, sid, comName, baud) {
    if (sid) {
        if (sid !== '1') {
            let socket = getSocketBySid(sid);
            socket ?
                socket.emit('communicate', { Open: true, Port: comName, Baud: baud }) :
                sidNotFound();
        }
    } else
        sidInvalid();
    return;
}

/**
 * Send incoming messages back to front-side by websocket.
 * @param {string} e Event
 * @param {string} sid Socket's id
 * @param {string} data Incoming messages
 * @returns {void} void
 */
function resultMessage(e, sid, data) {
    if (sid && sid !== '1') {
        let socket = getSocketBySid(sid);
        socket ? socket.emit('message', data) : sidNotFound();
    }
    else if (sid && sid === '1')
        console.log(data);
    else
        sidInvalid();
    return;
}

/**
 * Send resutl of close command to front-side by websocket.
 * @param {string} event Event
 * @param {string} sid Socket's id
 * @returns {void} void
 */
function resultClose(e, sid) {
    if (sid) {
        if (sid !== '1') {
            let socket = getSocketBySid(sid);
            socket ? socket.emit('communicate', { Close: true }) : sidNotFound();
        }
    } else
        sidInvalid();
    return;
}

/**
 * Send resutl of update command to front-side by websocket.
 * @param {string} event Event
 * @param {string} sid Socket's id
 * @param {number} baud Baud-rate
 * @returns {void} void
 */
function resultUpdate(e, sid, baud) {
    if (sid) {
        if (sid !== '1') {
            let socket = getSocketBySid(sid);
            socket ?
                socket.emit('communicate', { updateBaud: true, baud: baud }) :
                sidNotFound();
        }
    } else
        sidInvalid();
    return;
}

/**
 * Handle error messages, & send result to front-side by websocket, based
 * on error messages.
 * @param {Error} err Error
 * @param {string} name Event
 * @param {string} sid Socket's id
 * @param {number} data Data to send
 * @returns {void} void
 */
function handleError(e, err, name, sid, data) {
    console.warn(err);
    let res = null;
    if (name === 'open') {
        res = { Open: false, Error: err.message };
    } else if (name === 'close') {
        res = { Close: false, Error: err.message };
    } else if (name === 'update') {
        res = { updateBaud: false, baud: data[0], Error: err.message };
    }
    if (name !== 'list') {
        if (sid) {
            if (sid !== '1') {
                let socket = getSocketBySid(sid);
                socket ? socket.emit('communicate', res) : sidNotFound();
            }
        } else
            sidInvalid();
    }
    return;
}

function socketConnect(socket) {
    const sid = socket.id;
    socket.emit('version', version);
    socket.on('command', data => {
        if (data.cmd == 'list')
            listCmd();
        else if (data.cmd == 'open') {
            let { port, baud } = data.option;
            openCmd(sid, port, baud);
        }
        else if (data.cmd == 'close')
            closeCmd(sid);
        else if (data.cmd == 'send') {
            let { msg, postfix } = data.option;
            sendCmd(sid, msg, postfix);
        }
        else if (data.cmd == 'updateBaud') {
            let { baud } = data.option;
            updateCmd(sid, baud);
        }
        else if (data.cmd == 'relaunch')
            ipcRenderer.send('relaunch');
    });
    socket.on('disconnect', () => {
        ipcRenderer.sendTo(id, 'disconnect', sid);
        socket = null;
    });
}

/**
 * Send list command.
 * @returns {void} void
 */
function listCmd() {
    ipcRenderer.sendTo(id, 'handle_list');
    return;
}

/**
 * Send open command with com-name and baud-rate.
 * @param {string} sid Socket's id
 * @param {string} port Com-name
 * @param {number|string} baud Baud-rate
 * @returns {void} void
 */
function openCmd(sid, port, baud) {
    typeof (baud) === 'string' ? baud = parseInt(baud) : '';
    ipcRenderer.sendTo(id, 'handle_open', sid, port, baud);
    return;
}

/**
 * Send close command.
 * @param {string} sid Socket's id
 * @returns {void} void
 */
function closeCmd(sid) {
    ipcRenderer.sendTo(id, 'handle_close', sid);
    return;
}

/**
 * Send sendding command with message and postfix.
 * @param {string} sid Socket's id
 * @param {string} msg Message to send
 * @param {string} pf Postfix
 * @returns {void} void
 */
function sendCmd(sid, msg, pf) {
    ipcRenderer.sendTo(id, 'handle_send', sid, msg, pf);
    return;
}

/**
 * Send update command with baud-rate.
 * @param {string} sid Socket's id
 * @param {number|string} baud Baud-rate
 * @returns {void} void
 */
function updateCmd(sid, baud) {
    typeof (baud) === 'string' ? baud = parseInt(baud) : '';
    ipcRenderer.sendTo(id, 'handle_update', sid, baud);
    return;
}

/**
 * Stop & wait for a few seconds.
 * @param {number} sec Number of waitting seconds
 * @returns {Promise}
 */
function waitTime(sec) {
    return new Promise(resolve => {
        setTimeout(() => resolve(true), sec * 1000);
    });
};

/**
 * Return Object serial which could be used to debug.
 */
function debugTool() {
    const serial = {
        info: () => console.log('serial\'methods:\nlist()  open(port,baud)  close()  send(text)  update(baud)  upload(port,board,code,verbose)  multiUpload(port,board,times,code)\nboard=\"leonardo\"||\"nodemcuv2\"'),
        list: listCmd,
        open: (port, baud = 9600) => openCmd('1', port, baud),
        close: () => closeCmd('1'),
        send: msg => sendCmd('1', msg, ''),
        update: (baud = 9600) => updateCmd('1', baud),
        upload: (port, board, code, verbose = false) => {
            return new Promise(resolve => {
                if (board === "leonardo")
                    board = "arduino:avr:leonardo";
                else if (board === "nodemcuv2")
                    board = "esp8266:esp8266:nodemcuv2";
                upload(port, board, code)
                    .then(result => {
                        if (verbose) {
                            if (typeof (result) === 'object')
                                for (let i in result)
                                    console.log(result[i]);
                            else
                                console.log(result);
                        }
                        resolve(true);
                    })
                    .catch(err => console.error(err));
            });
        },
        multiUpload: async function (port, board, times, code) {
            let i = 1, err = 0;
            while (i <= times) {
                console.log(`total: ${times}\tnow: ${i++}\t\terror: ${err}`);
                await this.upload(port, board, code).catch(() => err++);
                await waitTime(2);
            }
        }
    }
    Object.freeze(serial);
    serial.info();
    return serial;
}

// ------ Get id list & version number from mian process ------ //
const ids = ipcRenderer.sendSync('windowsid', 'already');
const id = ids[1];
const version = ipcRenderer.sendSync('version', 'already');

// ------ bind functions to ipcRenderer's events  ------ //
ipcRenderer.on('result_list', resultList);
ipcRenderer.on('result_open', resultOpen);
ipcRenderer.on('message', resultMessage);
ipcRenderer.on('result_close', resultClose);
ipcRenderer.on('result_update', resultUpdate);
ipcRenderer.on('error', handleError);

// ------ socket connection & disconnection  ------ //
io.on('connection', socket => socketConnect(socket));
ios.on('connection', socket => socketConnect(socket));

// ------ Post request: upload source code ------ //
app.post('/upload', (req, res) => {
    let { code, sid, comname } = req.body, err = null;
    const socket = getSocketBySid(sid); //获取连接的socket服务
    if (socket) {
        //发送上传中处理
        socket.emit('upload', { ProgrammerStatus: 'Starting' });
        //执行ampy
        upload(code, comname, socket).then(async () => {
            socket.emit('upload', { ProgrammerStatus: 'Done' });
        }).then(() => res.status(200).send('success')).catch(err => {
            res.status(200).send('success')
            let error = errHandler(err.message);
            socket.emit('upload', { ProgrammerStatus: 'Error', Error: error });
        });
    } else
        res.status(401).send('disconnection');

    // let {  port, code, sid } = req.body, err = null;
    // const socket = getSocketBySid(sid);
    // if (socket) {
    //     socket.emit('upload', { ProgrammerStatus: 'Starting' });
    //     upload(port, code)
    //         .then(async () => {
    //             waitTime(1.5).then(() => {
    //                 socket.emit('upload', { ProgrammerStatus: 'Done' });
    //                 // ipcRenderer.sendTo(id, 'handle_list');
    //             });
    //         })
    //         .then(() => res.status(200).send('success'))
    //         .catch(err => {
    //             console.log(err);
    //             let error = errHandler(err.message);
    //             socket.emit('upload', { ProgrammerStatus: 'Error', Error: error });
    //         });
    // } else
    //     res.status(401).send('disconnection');
});


// ------ Post request: upload source code ------ //
app.post('/pythonupload', (req, res) => {
    let { code, sid, comname } = req.body, err = null;
    const socket = getSocketBySid(sid); //获取连接的socket服务
    if (socket) {
        //发送上传中处理
        socket.emit('upload', { ProgrammerStatus: 'Starting' });
        //执行ampy
        pythonupload(code, comname, socket).then(async () => {
            socket.emit('upload', { ProgrammerStatus: 'Done' });
        }).then(() => res.status(200).send('success')).catch(err => {
            res.status(200).send('success')
            let error = errHandler(err.message);
            socket.emit('upload', { ProgrammerStatus: 'Error', Error: error });
        });
    } else
        res.status(401).send('disconnection');
});


// ------ Post request: upload source code ------ //
app.post('/pythonuploadfile', (req, res) => {
    let { code, sid, comname, name } = req.body, err = null;
    const socket = getSocketBySid(sid); //获取连接的socket服务
    if (socket) {
        //发送上传中处理
        socket.emit('upload', { ProgrammerStatus: 'Starting' });
        //执行ampy
        pythonuploadfile(code, name, comname, socket).then(async () => {
            socket.emit('upload', { ProgrammerStatus: 'Done' });
        }).then(() => res.status(200).send('success')).catch(err => {
            res.status(200).send('success')
            let error = errHandler(err.message);
            socket.emit('upload', { ProgrammerStatus: 'Error', Error: error });
        });
    } else
        res.status(401).send('disconnection');
});

// ------ Post request: upload source code ------ //
//, upload.single('test-upload')
app.post('/pythonuploadfilebyfile', (req, res) => {
    //let { sid, comname, name } = req.file, err = null;

    //等待传参的值
    req.on("data", function (c) {
        console.log(c)
    });
    if (!req.file) {
        console.log(req.file)
    }

    //req.files
    //const socket = getSocketBySid(sid); //获取连接的socket服务

    // if (socket) {
    //     //发送上传中处理
    //     socket.emit('upload', { ProgrammerStatus: 'Starting' });
    //     //执行ampy
    //     pythonuploadfile(code, name, comname, socket).then(async () => {
    //         socket.emit('upload', { ProgrammerStatus: 'Done' });
    //     }).then(() => res.status(200).send('success')).catch(err => {
    //         res.status(200).send('success')
    //         let error = errHandler(err.message);
    //         socket.emit('upload', { ProgrammerStatus: 'Error', Error: error });
    //     });
    // } else
    //     res.status(401).send('disconnection');
});

//获取参数使用
// us.getParm = function (req, cb) {

// }

app.post('/pythonreset', (req, res) => {
    let { code, sid, type, comname } = req.body, err = null;
    const socket = getSocketBySid(sid); //获取连接的socket服务
    if (socket) {
        //发送上传中处理
        socket.emit('upload', { ProgrammerStatus: 'Starting' });
        //执行ampy
        pythonreset(comname, socket).then(async () => {
            socket.emit('upload', { ProgrammerStatus: 'Done' });
        }).then(() => res.status(200).send('success')).catch(err => {
            res.status(200).send('success')
            let error = errHandler(err.message);
            socket.emit('upload', { ProgrammerStatus: 'Error', Error: error });
        });
    }
    else {
        res.status(401).send('disconnection');
    }
});


app.post('/getmcnty', (req, res) => {
    let { comname, sid } = req.body;

    const socket = getSocketBySid(sid); //获取连接的socket服务
    if (socket) {
        //执行ampy
        getmcnty(comname, socket).then(async (typeval) => {
            res.status(200).send(typeval)
        }).then((typeval) => res.status(200).send(typeval)).catch(err => {
            res.status(401).send(err.message)
        });
    }
});

app.post('/sendcontent', (req, res) => {
    let { content, comname, sid } = req.body;
    const socket = getSocketBySid(sid); //获取连接的socket服务
    if (socket) {
        //执行ampy
        sendcontent(content, comname, socket).then(async (typeval) => {
            res.status(200).send(typeval)
        }).then((typeval) => res.status(200).send(typeval)).catch(err => {
            res.status(401).send(err.message)
        });
    }
});


app.post('/pythoncmd', (req, res) => {
    let { code, comname, sid } = req.body;
    const socket = getSocketBySid(sid); //获取连接的socket服务
    if (socket) {
        //执行ampy
        pythoncmd(code, comname, socket).then(async (typeval) => {
            res.status(200).send(typeval)
        }).then((typeval) => res.status(200).send(typeval)).catch(err => {
            res.status(401).send(err.message)
        });
    }
});


// ------ Post request: upload source code ------ //
app.post('/uploadfile', (req, res) => {
    let { code, sid, comname, name } = req.body, err = null;
    const socket = getSocketBySid(sid); //获取连接的socket服务
    if (socket) {
        //发送上传中处理
        socket.emit('upload', { ProgrammerStatus: 'Starting' });
        //执行ampy
        uploadfile(code, name, comname, socket).then(async () => {
            socket.emit('upload', { ProgrammerStatus: 'Done' });
        }).then(() => res.status(200).send('success')).catch(err => {
            res.status(200).send('success')
            let error = errHandler(err.message);
            socket.emit('upload', { ProgrammerStatus: 'Error', Error: error });
        });
    } else
        res.status(401).send('disconnection');
});



// ------ Post request: upload source code ------ //
app.post('/testSerialPort', (req, res) => {
    let { code, sid, comname, name } = req.body, err = null;

    const serialPort = new SerialPort(comname, { baudRate: 115200 }, err => {
        if (!err) {
            serialPort.on('data', function (data) {
                console.log(data);
            });
        } else
            errorHandler(err, 'open', sid);
    });


});

//clearCache();

//codingagent
function CodingAlive() {
    // setInterval(function () {
    //     netRequest('/plugin/alive', { "PluginID": "CocoRoboX" })
    // }, 1500)
    // netRequest('/plugin/alive', { "PluginID": "CocoRoboX" });
}

//CodingAlive();

function netRequest(p, j) {
    // var contents = querystring.stringify(j);
    // var contents = JSON.stringify(j)
    // var options = {
    //     url: "http://127.0.0.1:8991" + p,
    //     method: 'POST',
    //     headers: {
    //         'Content-Type': 'text/plain'
    //     },
    //     body: contents
    // }
    // try {
    //     request(options, function (error, response) {
    //         if (error) throw new Error(error);
    //     });
    // }
    // catch (e) {

    // }
}

window.serial = debugTool();