const Client = require('ftp');
const fs = require('fs');
const readline = require('readline');

import { NextObserver } from 'rxjs/Observer';
import { Observable } from 'rxjs/Rx';

interface server {
    name: string;
    path: string;
    version: string;
    java_version: string;
}

export class FTPClient {
    username: string;
    password: string;
    host: string;
    port: number;
    c: any;

    constructor() {
    }

    init(username, password, host, port) {
        console.log("initiating FTP connection to:" + host + "on port:" + port);

        this.username = username;
        this.password = password;
        this.host = host;
        this.port = port;
        this.c = new Client();

        console.log("Client created");
    }

    connect() {
        console.log("About to start connection");

        this.c.on('ready', () => {
            this.c.list((err: any, list: any) => {
                if (err) throw err;

                console.dir(list);
                this.c.end();
            });
        });

        // connect to localhost:21 as anonymous
        var connectProps = {
            host : this.host,
            port : this.port,
            user : this.username,
            password : this.password
        };

        console.log("Connecting now...");
        this.c.connect(connectProps);
    }

    public lookForServers(name: string): Observable<any[]> {
        return Observable.create((observer: NextObserver <any[]>) => {
            let servers = [];
            let whereAreWe = 0;
            let possibles = [ "/path/to/servers/" ];

            for (var i = 0; i < possibles.length; i++) {
                whereAreWe = i;

                this.c.list(possibles[ i ], false, (err: any, list: any) => {
                    for (var p = 0; p < list.length; p++) {
                        this.grabMessagesLog(possibles[ whereAreWe ] + list[ p ].name)
                        .subscribe((data: any) => {
                                let server_version = data;

                                servers.push({
                                    name : list[ p ].name,
                                    path : possibles[ whereAreWe ] + list[ p ].name,
                                    version : server_version
                                });

                                observer.next(servers);
                                observer.complete();
                            }
                        );
                    }
                });
            }
        });
    }

    grabMessagesLog(path): Observable<any> {
        return Observable.create((observer: NextObserver <any>) => {
            let result = '';
            let unix = Math.round(+new Date() / 1000);
            this.c.binary(function(err) {
                console.log(err);
            });

            this.c.get(path + "/logs/messages.log", (err, stream) => {
                if (err) throw err;

                stream.once('close', () => {
                    this.c.end();
                    this.getServerMetadataFromMessagesLog(unix + "_messages.log")
                    .subscribe((data) => {
                        stream.pipe(fs.createWriteStream(unix + "_messages.log"));

                        observer.next(data);
                        observer.complete();
                    });
                });
            });
        });
    }

    getServerMetadataFromMessagesLog(path): Observable<any> {
        return Observable.create((observer: NextObserver <any>) => {
            let lineReader = readline.createInterface({
                input : fs.createReadStream(path)
            });

            let server_version = "";
            let java_version = "";
            let line_no = 0;

            lineReader.on('line', function(line) {
                line_no++;
                console.log("line number is:" + line_no);

                if (line.includes("STUFF") && line.includes("FLAG2") && line_no == 2) {
                    var first = line.split("FLAG2")[ 1 ];
                    var last = first.split(" (")[ 0 ];
                    var version = "FLAG2" + last;
                    this.server_version = version;
                    console.log("version is:" + version);
                }

                if (line.includes("java.version =")) {
                    var javav = line.split("java.version =")[ 1 ];
                    this.java_version = javav;
                    lineReader.close();
                }

                console.log('Line from file:', line);
            });

            lineReader.on('close', () => {
                var res = {
                    version : server_version,
                    java_version : java_version
                };

                alert("RES IS:" + JSON.stringify(res));

                observer.next(res);
                observer.complete();
            });
        });
    }
}