/// <reference path="../../typings/browser/ambient/jquery/index.d.ts" />
import { Injectable } from "@angular/core";
import { Http } from "@angular/http";

@Injectable()
export class StrongsService
{
    result: StrongsResult;
    count = 0;

    constructor(private http: Http)
    {
    }

    getResultAsPromise(sn: number, dict: string): Promise<StrongsResult>
    {
        return new Promise((resolve, reject) => { resolve(this.getResult(sn, dict)); });
    }

    getResult(sn: number, dict: string): StrongsResult
    {
        const self = this;
        this.result = {
            prefix: "",
            sn: -1,
            strongs: [],
            def: null,
            rmac: null,
            crossrefs: null,
            rmaccode: "",
            status: 0,
            msg: ":)"
        };
        let url = dict + Math.ceil(sn / 100) + ".json";
        if (dict === "grk")
        {
            self.result.prefix = "G";
            if (sn > 5624 || sn < 1)
            {
                self.result.status = -1;
                self.result.msg = "Strongs Number G" + sn + " is out of range.";
            }
        }
        else
        {
            self.result.prefix = "H";
            if (sn > 8674 || sn < 1)
            {
                self.result.status = -1;
                self.result.msg = "Strongs Number H" + sn + " is out of range.";
            }
        }
        this.result.sn = sn;

        if (self.result.status == -1)
            return self.result;

        $.ajax({
            async: false,
            type: "GET",
            url: "data/strongs/" + url,
            dataType: "json",
            success: function (d: StrongsDefinition[], t, x)
            {
                self.result.strongs = d;
            },
            error: function (request, status, error)
            {
                console.log(error);
                self.result.status = -1;
                self.result.msg = "Unable to retrieve Strongs Data for " + self.result.prefix + self.result.sn;
            }
        });

        if (self.result.status === -1)
            return self.result;

        self.result.def = self.result.strongs.find(el => (el.i === this.result.prefix + this.result.sn));
        self.result.strongs = [];

        $.ajax({
            async: false,
            type: "GET",
            url: "data/strongscr/cr" + url,
            dataType: "json",
            success: function (d: StrongsCrossReference[], t, x)
            {
                for (let cr of d)
                {
                    if (cr.id.toUpperCase() == self.result.prefix + self.result.sn)
                    {
                        self.result.crossrefs = cr;
                        break;
                    }
                }
            },
            error: function (request, status, error)
            {
                console.log(error);
                self.result.status = -1;
                self.result.msg = "Unable to retrieve Strongs Cross References for " + self.result.prefix + self.result.sn;
            }
        });

        if (self.result.status === -1)
            return self.result;

        if (dict === "grk")
        {
            url = "data/rmac/rs" + (Math.ceil(sn / 1000)) + ".json";
            let rmac_cross_references: RMACCrossReference[];

            // rmac is a two get process.
            $.ajax({
                async: false,
                type: "GET",
                url: url,
                dataType: "json",
                success: function (d: RMACCrossReference[], t, x)
                {
                    rmac_cross_references = d;
                },
                error: function (request, status, error)
                {
                    console.log(error);
                }
            });

            // deal with RMAC
            let tmp = $.grep<RMACCrossReference>(rmac_cross_references, (el, i) => { return el.i == sn + "" ? true : false; });
            if (tmp.length == 0)
                return this.result;

            this.result.rmaccode = tmp[0].r;
            if (this.result.rmaccode != undefined)
            {
                url = `data/rmac/r-${this.result.rmaccode.substring(0, 1)}.json`;
                $.ajax({
                    async: false,
                    type: "GET",
                    url: url,
                    dataType: "json",
                    success: function (d: RMACDefinition[], t, x)
                    {
                        for (let rmac of d)
                        {
                            if (rmac.id.toLowerCase() == self.result.rmaccode)
                            {
                                self.result.rmac = rmac;
                                break;
                            }
                        }
                    },
                    error: function (request, status, error)
                    {
                        console.log(error);
                    }
                });
            }
        }
        return this.result;
    }
}
export type StrongsResult =
    {
        prefix: string,
        sn: number,
        strongs: StrongsDefinition[],
        def: StrongsDefinition,
        rmac: RMACDefinition,
        crossrefs: StrongsCrossReference,
        rmaccode: string,
        status: number,
        msg: string
    };

type StrongsDefinition = { n: number, i: string, tr: string, de: StrongsDefinitionPart[], lemma: string, p: string }
type StrongsDefinitionPart = { sn: string, w: string }
type StrongsCrossReference =
    {
        id: string, // strongs id H1|G1
        t: string, // strongs testament grk|heb
        d: string, // strongs word/data Aaron {ah-ar-ohn'}
        ss: [
            {
                w: string,
                rs: [
                    { r: string }
                ]
            }
        ]
    }

type RMACDefinition = { id: string, d: string[] }

type RMACCrossReference = { i: string, r: string }