import { Injectable } from '@angular/core';
import { Observable, Subject } from 'rxjs';
import { filter } from 'rxjs/operators';
import { IncomingHeader, IncomingPacket, OutgoingHeader, OutgoingPacket } from '../codec';

@Injectable()
export class SocketService
{
    private _server: WebSocket;

    private _statusChange: Subject<number>;
    private _incomingPacket: Subject<IncomingPacket>;

    private _pingCount: number;

    constructor()
    {
        this._server            = null;

        this._statusChange      = new Subject();
        this._incomingPacket    = new Subject();

        this._pingCount         = 0;
    }

    public connect(): void
    {
        this._server = new WebSocket('wss://api.habboapi.com');

        this._statusChange.next(this._server.readyState);

        this._server.onopen     = this.onOpen.bind(this);
        this._server.onmessage  = this.onMessage.bind(this);
        this._server.onclose    = this.onClose.bind(this);
        this._server.onerror    = this.onError.bind(this);
    }

    private onOpen(event: Event): void
    {
        this._pingCount = 0;

        this._statusChange.next(this._server.readyState);
    }

    private onMessage(event: MessageEvent): void
    {
        const reader = new FileReader();

        reader.readAsArrayBuffer(event.data);

        reader.onloadend = event =>
        {
            const data: number[] = Array.from(new Uint8Array(<ArrayBuffer> reader.result));

            const packets: IncomingPacket[] = [];

            const originalPacket        = new IncomingPacket(data);
            const originalPacketLength  = originalPacket.bytesLength;

            let packetLength    = originalPacket.packetLength + 4;
            let completedLength = 0;

            if(originalPacketLength > packetLength)
            {
                for(let i = 0; i < originalPacketLength; i += packetLength)
                {
                    const packet = new IncomingPacket(data.slice(i, i + packetLength));

                    if(packet.header !== 0) packets.push(packet);

                    packetLength    = packet.packetLength + 4;
                    completedLength = completedLength + packetLength;

                    this._incomingPacket.next(packet);
                }
            }
            else
            {
                this._incomingPacket.next(originalPacket);
            }
        }
    }

    private onClose(event: Event): void
    {
        this._statusChange.next(this._server.readyState);
    }

    private onError(error: Event): void
    {
        console.log(error);
    }

    public requestPong()
    {
        this.sendPacket(new OutgoingPacket(OutgoingHeader.CLIENT_PING).writeInt(this._pingCount).prepare());
    }

    public receivePong(packet: IncomingPacket)
    {
        if(packet && packet.readInt() === this._pingCount) this._pingCount++;
    }

    public packetSubscription(header: IncomingHeader): Observable<IncomingPacket>
    {
        const observable = this._incomingPacket
            .pipe(filter(packet => packet.header.toString() === header.toString()));

        return observable;
    }

    public sendPacket(...packets: OutgoingPacket[]): void
    {
        if(this._server && this._server.readyState === WebSocket.OPEN)
        {
            let somePackets: OutgoingPacket[] = [];
            somePackets = somePackets.concat(packets);

            if(somePackets)
            {
                const totalPackets = packets.length;

                for(let i = 0; i < totalPackets; i++)
                {
                    const packet = packets[i];

                    if(packet instanceof OutgoingPacket)
                    {
                        if(packet.isPrepared)
                        {
                            this._server.send(new Uint8Array(packet.bytes))
                        }
                    }
                }
            }
        }
    }

    public get server(): WebSocket
    {
        return this._server;
    }

    public get statusChange(): Subject<number>
    {
        return this._statusChange;
    }

    public get incomingPacket(): Subject<IncomingPacket>
    {
        return this._incomingPacket;
    }
}