"use strict";
var console = process.console;
var yamlConfig = require('node-yaml-config')
var path = require('path')
var async = require('async')
var config = yamlConfig.load(path.join(__dirname, '/../../config/config.yml'))

var lib = require('../lib')

// lib.authorize()
// lib.listEvents()
// lib.createEvent()

var url = config.server.url
var port = config.server.port
var URLCALENDAR = config.urlcalendar

function rmsRes(res) {
    this._40401 = function (data) {
        res.json({
            resultCode: '40401',
            resultDescription: 'Data not found'
        }).end()
    }
    this._50000 = function (data) {
        console.tag('ERROR!').time().file().error(data)
        res.json({
            resultCode: '50000',
            resultDescription: 'System Error',
        }).end()
    }
    this._40301 = function (data) {
        res.json({
            resultCode: '40301',
            resultDescription: 'Missing or invalid parameter'
        }).end()
    }
    this._20000 = function (data) {
        console.tag().time().file().info(data)
        res.json({
            resultCode: '20000',
            resultDescription: 'Success',
            data: data
        }).end()
    }
}

function strToTime(date) {
    var strDate = new Date(date)
    return strDate.getTime()
}

function ggToKendo(data) {
    var dataToArr = []
    try {
        for (var n = 0; n < data.items.length; n++) {
            dataToArr.push({
                "TaskID": data.items[n].id,
                "EventTypeID": checkObjEmpty(data.items[n].extendedProperties, 'private', 'EventTypeID'),
                "PropertyID": checkObjEmpty(data.items[n].extendedProperties, 'private', 'PropertyID'),
                "Title": data.items[n].summary,
                "Description": data.items[n].description,
                "StartTimezone": "Asia/Bangkok",
                "Start": new Date(data.items[n].start.dateTime),
                "End": new Date(data.items[n].end.dateTime),
                "EndTimezone": "Asia/Bangkok",
                "RecurrenceRule": null,
                "RecurrenceID": null,
                "RecurrenceException": null,
                "IsAllDay": false
            })
        }
    } catch (error) {
        console.tag().time().file().error(error.message)
    } finally {
        return dataToArr
    }
}

function home(req, res) {
    res.render('index')
}

function index(req, res) {
    var rms = new rmsRes(res)

    console.tag().time().file().log(req.body)
    lib.getNewToken((err, authUrl) => {
        if (err) {
            rms._50000(err)
        } else {
            rms._20000(authUrl)
        }
    });
}

function setToken(req, res) {
    var rms = new rmsRes(res)

    console.tag().time().file().log(req.body)
    var code = req.body.code
    lib.setNewToken(code, (err, token) => {
        if (err) {
            rms._50000(err)
        } else {
            rms._20000(token)
        }
    })
}

function events(req, res) {
    var rms = new rmsRes(res)
    console.tag().time().file().log(req.body)
    lib.authorize((err, auth, authUrl) => {
        if (err) {
            rms._50000(err)
        } else {
            lib.listCalendar(auth, (err, response) => {
                if (err) {
                    console.error(err);
                } else {
                    console.info(response);
                }
            })
            lib.listEvents(auth, (err, response) => {
                if (err) {
                    if (authUrl) {
                        console.tag().time().file().info(authUrl)
                        rms._20000(authUrl)
                    } else {
                        rms._50000(err)
                    }
                } else {
                    res.json(ggToKendo(response));
                    res.end();
                }
            })
        }
    })
}

function eventCreate(req, res) {
    var rms = new rmsRes(res)

    console.tag().time().file().log(req.body)
    let payload = req.body
    if (typeof payload.models == "string") {
        payload.models = JSON.parse(req.body.models)
        payload = payload.models[0]
    }

    lib.authorize((err, auth) => {
        let options = lib.eventBuilder(payload)
        if (err) {
            rms._50000(err)
        } else {
            options.auth = auth
        }

        lib.createEvent(options, (err, result) => {
            if (err) {
                rms._50000(err)
            } else {
                rms._20000(result)
            }
        })
    })
}

function oauth2callback(req, res) {
    var rms = new rmsRes(res)

    var code = req.query.code
    lib.setNewToken(code, (err, token) => {
        if (err) {
            rms._50000(err)
        } else {

            res.redirect(URLCALENDAR)
        }
    })
}

function eventDelete(req, res) {
    var rms = new rmsRes(res)

    console.tag().time().file().log(req.body)
    let payload = req.body
    if (typeof payload.models == "string") {
        payload.models = JSON.parse(req.body.models)
        payload = payload.models[0]
    }
    lib.authorize((err, auth) => {
        let options = lib.deleteBuilder(payload)
        if (err) {
            rms._50000(err)
        } else {
            console.tag().time().file().info(auth)
            options.auth = auth
        }

        lib.deleteEvent(options, (err, result) => {
            if (err) {
                rms._50000(err)
            } else {
                rms._20000(result)
            }
        })
    })
}

function eventUpdate(req, res) {
    var rms = new rmsRes(res)

    console.tag().time().file().log(req.body)
    let payload = req.body
    if (typeof payload.models == "string") {
        payload.models = JSON.parse(req.body.models)
        payload = payload.models[0]
    }
    lib.authorize((err, auth) => {
        let options = lib.updateBuilder(payload)
        if (err) {
            rms._50000(err)
        } else {
            console.tag().time().file().info(auth)
            options.auth = auth
        }

        lib.updateEvent(options, (err, result) => {
            if (err) {
                rms._50000(err)
            } else {
                rms._20000(result)
            }
        })
    })
}

function checkObjEmpty(obj, parm, name) {
    if (obj) {
        if (Object.getOwnPropertyNames(obj)) {
            if (name == 'EventTypeID') {
                return obj[parm].eventTypeID
            } else if (name == 'PropertyID') {
                return obj[parm].propertyID
            }
        }
    } else {
        return
    }

}

function createCalendar(req, res) {
    var rms = new rmsRes(res)
    let options = {};
    lib.authorize((err, auth) => {
        if (err) {
            rms._50000(err)
        } else {
            options.auth = auth;
            options.summary = req.body.summary;
            lib.createCalendar(options, (err, result) => {
                if (err) {
                    rms._50000(err)
                } else {
                    rms._20000(result)
                }
            })
        }
    })
}

function getCalendar(req, res) {
    var rms = new rmsRes(res);

    lib.authorize((err, auth) => {
        if (err) {
            rms._50000(err)
        } else {
            lib.getCalendar(auth, (err, response) => {
                if (err) {
                    rms._50000(err)
                } else {
                    rms._20000(response)
                }
            })
        }
    })
}

function deleteCalendar(req, res) {
    var rms = new rmsRes(res);
    var options = {};
    lib.authorize((err, auth) => {
        if (err) {
            rms._50000(err)
        } else {
            options.auth = auth;
            options.calendarId = req.body.id;
            lib.deleteCalendar(options, (err, response) => {
                if (err) {
                    rms._50000(err)
                } else {
                    rms._20000(response)
                }
            })
        }
    })
}

function refreshToken(req, res) {
    var rms = new rmsRes(res);
    var options = {};
    lib.authorize((err, auth) => {
        if (err) {
            rms._50000(err)
        } else {
            options.auth = auth;
            lib.refreshToken(options, (err, response) => {
                if (err) {
                    rms._50000(err)
                } else {
                    rms._20000(response)
                }
            })
        }
    })
}

module.exports.index = index;
module.exports.events = events;
module.exports.eventCreate = eventCreate;
module.exports.eventUpdate = eventUpdate;
module.exports.eventDelete = eventDelete;
module.exports.home = home;
module.exports.setToken = setToken;
module.exports.oauth2callback = oauth2callback;
module.exports.createCalendar = createCalendar;
module.exports.getCalendar = getCalendar;
module.exports.deleteCalendar = deleteCalendar;
module.exports.refreshToken = refreshToken;