import WebSocket from 'ws';
import { windowEmitter } from './windowEmitter';
import { ipcMain  } from "electron";

const EventEmitter = require('events');

class SocketEmitter extends EventEmitter {}

export const socketEmitter = new SocketEmitter();

interface RenderMessage  {
  type: 'render';
  content: string;
  context: string;
  subContext: string;
  modifiers: string;
  time: string;
  id: string;
}

interface UserCreds {
    email: string;
    password: string;
}

const ip = 'ws://localhost';
const port = 8081;
const reconnectTimeout = 3000; //ms
let socket: WebSocket;
let success = false;
let auth = false;

const receiveMessage = (message: string): void => {

    while(!auth) {
        console.log('window emitter @ session.ts recieve')
        windowEmitter.emit('auth-res', message);
        return;
    }

    const parsed: RenderMessage  = JSON.parse(message);
      if (parsed.type === "render") {
        windowEmitter.emit('ipc-renderer', {
            endpoint: 'render-message',
            message: parsed
        });
      }
}

const authUser = async (event: any, payload: string | UserCreds | null): Promise<string> => {
    return new Promise((resolve, reject) => {
        console.log('authenticating...');
        console.log('window emitter @ session.ts auth')
        windowEmitter.on('auth-res', (res: string) => {
            if (res === 'locked') {
                reject(res);
            } else {
                auth = true;
                resolve(res);
            }
        });
        if (!payload) {
            socket.send('no-token');
        } else if (typeof payload === 'string' || payload instanceof String) {
            socket.send(payload);
        } else {
            socket.send(JSON.stringify(payload));
        }
    });
};

export const initSession = () => {
    if (socket) {
        socket.removeAllListeners();
        socket.terminate();
        socket.close();
        success = false;
    }

    console.log('Connecting to Crimata Servers...');

    socket = new WebSocket(`${ip}:${port}`);
    socket.binaryType = 'arraybuffer';

    // handle renderer auth-token event
    ipcMain.removeHandler('auth-user'); // avoid setting duplicate handlers
    ipcMain.handle('auth-user', authUser);

    socket.on('open', () => {
        console.log('Success! Connected to Crimata.');

        // fetch token from renderer
        windowEmitter.emit('ipc-renderer', {
            endpoint: 'fetch-token',
            message: null
        });
        success = true;

    });

    socket.on('error', (e) => {
        console.log('ERROR: Failed to connect.');
        socket.removeAllListeners();
        socket.close();
        setTimeout(()=> {
            if (!success) {
                console.log('Attempting reconnect.');
                initSession();
            }
        }, reconnectTimeout);

    })

    socket.on('close', () => {
        console.log('Connection droped. Restarting.')
        initSession();
    })

    socket.on("message", receiveMessage);
}

export const sendMessage = (content: string | Buffer) => {
    if (content instanceof Buffer) {
        socket.send(content);
    } else if (content){
        socket.send(JSON.stringify(content));
    }
}