function log(message) {
    let time = new Date().toUTCString();
    console.log(`[${time}]`, message);
}

const _port = process.env.PORT || 6942;
const ws = require('ws');
//const fs = require('fs');
const WSServer = ws.Server;
const http = require('http').createServer();
const server = new WSServer({ server: http });
const app = require('./app');
const crypto = require('crypto');

let clients = [];
let participants = {};
let rooms = {};

let index = 10;
let temp_user = `face${index}`;

let lobbyOwner = "abcdef0123456789abcdef01"

class Participant {
    constructor(_id, name, c) {
        this._id = _id;
        this.name = name;
        this.color = "#123456";
        this.id = _id;
        this.x = 60;
        this.y = 50;
        this.c = c;
    }
}

class Room {
    constructor(name, settings) {
        this.name = name;
        this._id = this.name;

        this.ppl = {};
        this.banlist = {};

        this.crown = {};
        
        this.settings = settings;

        this.isLobby = this.name.startsWith("lobby") || this.name.startsWith("test/");
    }

    add(participant) {
        if (this.banlist[participant._id]) return participant.setChannel("test/ohnoguys");
        return;
    }
}

const broadcast = data => {
    for (let i = 0; i < clients.length; i++) clients[i].send(data);
};

const broadcastExceptClient = (client, data) => {
    for (let i = 0; i < clients.length; i++) if (clients[i] != client) clients[i].send(data);
};

const broadcastToRoom = (room, data) => {
    for (let part of Object.entries(room.ppl)) if (part[1]._id !== lobbyOwner) part[1].c.send(data);
}

const broadcastToRoomExceptId = (room, pid, data) => {
    for (let part of Object.entries(room.ppl)) if (part[1]._id !== lobbyOwner && part[1]._id !== pid) {
        /*console.log(part[1]._id),*/ part[1].c.send(data);
    } 
}


rooms["lobby"] = new Room("lobby");
rooms["realistic"] = new Room("realistic");
rooms["lobby"].ppl["face00"] = {
    _id: lobbyOwner,
    name: "Large Dummy",
    color: "#654321",
    id: lobbyOwner,
    x: 60,
    y: 50
}

server.on('connection', c => {
    clients.push(c);
    let myId;
    let myName;
    let myOldRoom;
    let myRoom;


    // todo: C message

    // first connect B
    c.send(JSON.stringify([{
        m: "b",
        code: "test-code-yes"
    }]));

    // now listen

    c.on('message', msg => {
        let data;

        try {
            data = JSON.parse(msg)[0];
        } catch (e) {
            log(e);
            data = {m: "none"};
        }

        console.log(data.m);

        if (data !== undefined && data !== null) switch (data.m) {
            case "hi":
                // server hi

                index++;
                temp_user = `face${index}`;
                myName = `Dummy ${index}`;

                //myId = temp_user;
                console.log(c._socket.remoteAddress);
                myId = crypto.createHmac("sha256", "23FireFoxId").update(temp_user).digest("hex").substring(0,24);
                console.log(myId);

                c.send(JSON.stringify([{
                    m: "hi",
                    t: Date.now(),
                    u: {
                        _id: myId,
                        name: myName,
                        color: "#ff8080",

                    },
                    token: `${myId}.test-token-yes`,
                    permissions: {}
                }]));

                participants[myId] = new Participant(myName, myId, c);
                break;

            case "ch":
                let room_name = data._id.trim();

                if (myRoom !== room_name && room_name && room_name !== "") {
                    myOldRoom = myRoom;
                    myRoom = room_name;

                    if (rooms[room_name] === undefined) rooms[room_name] = new Room(room_name);

                    // send myself to all users in the room
                    broadcastToRoom(rooms[room_name], JSON.stringify([{
                        m: 'p',
                        _id: myId,
                        name: myName,
                        color: "#123456",
                        id: myId,
                        x: 60,
                        y: 50
                    }]));

                    rooms[room_name].ppl[myId] = {
                        _id: myId,
                        name: myName,
                        color: "#123456",
                        id: myId,
                        x: 60,
                        y: 50,
                        c: c
                    };

                    let _ppl = [];
                    for (let part of Object.entries(rooms[room_name].ppl)) _ppl.push({
                        _id: part[1]._id,
                        name: part[1].name,
                        color: part[1].color,
                        id: part[1].id,
                        x: part[1].x,
                        y: part[1].y
                    });

                    console.log(_ppl);

                    c.send(JSON.stringify([{
                        m: "ch",
                        ch: {
                            settings: {
                                chat: true,
                                color: "#654321",
                                visible: true,
                                limit: 10,
                                crownsolo: false,
                                "no cussing": false,
                                minOnlineTime: 0,
                                color2: "#123456"
                            },
                            id: room_name,
                            _id: room_name,
                            count: Object.keys(rooms[room_name].ppl).length,
                            crown: {
                                endPos: {
                                    x: 50,
                                    y: 50
                                },
                                startPos: {
                                    x: 50,
                                    y: 25
                                },
                                userId: lobbyOwner,
                                time: Date.now(),
                                participantId: lobbyOwner
                            }
                        },
                        ppl: _ppl,
                        p: myId
                    }]));

                    

                    // send all users in room to me
                    for (let part of _ppl) {
                        c.send(JSON.stringify([{
                            m: 'p',
                            _id: part._id,
                            name: part.name,
                            color: part.color,
                            id: part._id,
                            x: part.x,
                            y: part.y
                        }]));
                    }

                    if (myOldRoom) {
                        delete rooms[myOldRoom].ppl[myId];
                        broadcastToRoom(rooms[myOldRoom], JSON.stringify([{
                            m: 'bye',
                            p: myId
                        }]));
                    }
                    
                }  
                break;

            case 'a':
                if (myRoom) {
                    let msg;
                    if (data.message && typeof data.message === "string")
                    msg = data.message.trim(); else break;
                    if (msg !== "") broadcastToRoom(rooms[myRoom], JSON.stringify([{
                        m: "a",
                        t: Date.now(),
                        a: msg,
                        p: {
                            _id: myId,
                            name: myName,
                            color: "#123456",
                            id: myId
                        }
                    }]));
                }
                break;

            case 'm':
                if (myRoom) {
                    let moveX = parseFloat(data.x);
                    let moveY = parseFloat(data.y);
                    console.log("what");
                    console.log(moveX, moveY);
                    if (typeof moveX === "number" && typeof moveY === "number"
                        && !isNaN(moveX) && !isNaN(moveY)) {
                        console.log("Huh!");
                        broadcastToRoomExceptId(rooms[myRoom], myId, JSON.stringify([{
                            m: "m",
                            x: data.x,
                            y: data.y,
                            id: myId
                        }]));
                    }
                }
                break;
                
        }
    });

    c.on('close', () => {
        delete rooms[myRoom].ppl[myId];
        broadcastToRoom(rooms[myRoom], JSON.stringify([{
            m: 'bye',
            p: myId
        }]));
    });
});

http.on('request', app);

http.listen(_port, () => {
    console.log("listening");
});