// Copyright 2014 Cognitect. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

"use strict";

goog.provide("com.cognitect.transit");
goog.require("com.cognitect.transit.util");
goog.require("com.cognitect.transit.impl.reader");
goog.require("com.cognitect.transit.impl.writer");
goog.require("com.cognitect.transit.types");
goog.require("com.cognitect.transit.eq");
goog.require("com.cognitect.transit.impl.decoder");
goog.require("com.cognitect.transit.caching");

/** @define {boolean} */
var TRANSIT_DEV = true;

/** @define {boolean} */
var TRANSIT_NODE_TARGET = false;

/** @define {boolean} */
var TRANSIT_BROWSER_TARGET = false;

/** @define {boolean} */
var TRANSIT_BROWSER_AMD_TARGET = false;

goog.scope(function() {

    /**
     * @class transit
     */
    var transit = com.cognitect.transit;

    var util    = com.cognitect.transit.util,
        reader  = com.cognitect.transit.impl.reader,
        writer  = com.cognitect.transit.impl.writer,
        decoder = com.cognitect.transit.impl.decoder,
        types   = com.cognitect.transit.types,
        eq      = com.cognitect.transit.eq,
        caching = com.cognitect.transit.caching;

    /**
     * @typedef {Map|com.cognitect.transit.types.TransitArrayMap|com.cognitect.transit.types.TransitMap}
     */
    transit.MapLike;

    /**
     * @typedef {Set|com.cognitect.transit.types.TransitSet}
     */
    transit.SetLike;

    /**
     * Create a transit reader instance.
     * @method transit.reader
     * @param {string=} type
     *     type of reader to construct.  Default to "json". For verbose mode
     *     supply "json-verbose".
     * @param {Object=} opts
     *     reader options. A JavaScript object to customize the writer Valid
     *     entries include "defaultHandler", and "handler". "defaultHandler"
     *     should be JavaScript function taking two arguments, the first is the
     *     tag, the second the value. "handlers" should be an object of tags to
     *     handle. The values are functions that will receive the value of matched
     *     tag. "preferBuffers" may be supplied to customize binary
     *     decoding. If available binary data will read as Node.js Buffers,
     *     If Buffer is not available or "prefersBuffers" is set to false
     *     data will be read as Uint8Array. If neither Buffer nor Uint8Array is
     *     available - defaults to tagged value that simply wraps the
     *     base64 encoded string.
     * @return {com.cognitect.transit.impl.reader.Reader} A transit reader.
     * @example
     *     var r = transit.reader("json", {
     *         handlers: {
     *            "point": function(v) { return new Point(v[0], v[1]); }
     *         }
     *     });
     */
    transit.reader = function(type, opts) {
        if(type === "json" || type === "json-verbose" || type == null) {
            type = "json";
            var unmarshaller = new reader.JSONUnmarshaller(opts);
            return new reader.Reader(unmarshaller, opts);
        } else {
            throw new Error("Cannot create reader of type " + type);
        }
    };

    /**
     * Create a transit writer instance.
     * @method transit.writer
     * @param {string=} type
     *     type of writer to construct. Defaults to "json". For verbose mode
     *     supply "json-verbose".
     * @param {Object=} opts
     *     writer options. A JavaScript object to customize the writer.
     *     "handlers" options, a transit.map of JavaScript constructor and
     *     transit writer handler instance entries. "handlerForForeign" option,
     *     for dealing with values from other JavaScript contexts. This function
     *     will be passed the unmatchable value and the installed handlers. The
     *     function should return the correct handler. Note if this function is
     *     provided, special handling for Objects will also be
     *     auto-installed to catch plain Objects from the foreign context.
     * @return {com.cognitect.transit.impl.writer.Writer} A transit writer.
     * @example
     *     var r = transit.writer("json", {
     *         handlers: transit.map([
     *            Point, PointHandler
     *         ])
     *     });
     */
    transit.writer = function(type, opts) {
        if(type === "json" || type === "json-verbose" || type == null) {
            if(type === "json-verbose") {
                if(opts == null) opts = {};
                opts["verbose"] = true;
            }
            var marshaller = new writer.JSONMarshaller(opts);
            return new writer.Writer(marshaller, opts);
        } else {
            var err = new Error("Type must be \"json\"");
            err.data = {type: type};
            throw err;
        }
    };

    /**
     * Create a transit writer handler.
     * @method transit.makeWriteHandler
     * @param {Object} obj
     *    An object containing 3 functions, tag, rep and stringRep. "tag" should
     *    return a string representing the tag to be written on the wire. "rep"
     *    should return the representation on the wire. "stringRep" is should
     *    return the string representation of the value. Optional
     *    "getVerboseHandler" should return a handler for writing verbose output.
     * @return {Object} A transit write handler.
     * @example
     *     var PointHandler = transit.makeWriteHandler({
     *          tag: function(p) { return "point"; },
     *          rep: function(p) { return [p.x, p.y]; },
     *          stringRep: function(p) { return null; }
     *     });
     */
    transit.makeWriteHandler = function(obj) {
        /** @constructor */
        var Handler = function(){};
        Handler.prototype.tag = obj["tag"];
        Handler.prototype.rep = obj["rep"];
        Handler.prototype.stringRep = obj["stringRep"];
        Handler.prototype.getVerboseHandler = obj["getVerboseHandler"];
        return new Handler();
    };

    transit.makeBuilder = function(obj) {
        /** @constructor */
        var Builder = function(){};
        Builder.prototype.init = obj["init"];
        Builder.prototype.add = obj["add"];
        Builder.prototype.finalize = obj["finalize"];
        Builder.prototype.fromArray = obj["fromArray"];
        return new Builder();
    };

    /**
     * Create a transit date.
     * @method transit.date
     * @param {number|string} x
     *     A number or string representing milliseconds since epoch.
     * @return {Date} A JavaScript Date.
     */
    transit.date = types.date;

    /**
     * Create an integer. If given a transit integer or a JavaScript
     *     number will simply return that value. Given a string will
     *     return a JavaScript number if the string represents an integer
     *     value in the 53bit range and a transit integer otherwise.
     * @method transit.integer
     * @param {number|string} s
     *     A value representing an integer.
     * @return {number|goog.math.Long} A JavaScript number or transit integer.
     */
    transit.integer = types.intValue;

    /**
     * Test if an object is a transit integer. Will return true if argument
     * is a 64 bit integer or a JavaScript number that has an interpretation as
     * an integer value, i.e. parseFloat(n) === parseInt(n)
     * @method transit.isInteger
     * @param {*} x
     *     Any JavaScript value.
     * @return {boolean} true if the value is a transit integer, false otherwise.
     */
    transit.isInteger = types.isInteger;

    /**
     * Create transit UUID from a string
     * @method transit.uuid
     * @param {string} s
     *     A string.
     * @return {com.cognitect.transit.types.UUID} A transit UUID.
     */
    transit.uuid = types.uuid;

    /**
     * Test if an object is a transit UUID.
     * @method transit.isUUID
     * @param {*} x
     *     Any JavaScript value.
     * @return {boolean} true if the vlaue is a transit UUID instance, false otherwise.
     */
    transit.isUUID = types.isUUID;

    /**
     * Create a transit big integer.
     * @method transit.bigInt
     * @param {string} s
     *     A string representing an arbitrary size integer value.
     * @return {com.cognitect.transit.types.TaggedValue} A transit big integer.
     */
    transit.bigInt =  types.bigInteger;

    /**
     * Test if an object is a transit big integer.
     * @method transit.isBigInt
     * @param {*} x
     *     Any JavaScript value.
     * @return {boolean} true if x is a transit big integer, false otherwise.
     */
    transit.isBigInt = types.isBigInteger;

    /**
     * Create a transit big decimal.
     * @method transit.bigDec
     * @param {string} s
     *     A string representing an arbitrary precisions decimal value.
     * @return {com.cognitect.transit.types.TaggedValue} A transit big decimal.
     */
    transit.bigDec =  types.bigDecimalValue;

    /**
     * Test if an object is a transit big decimal.
     * @method transit.isBigDec
     * @param {*} x
     *     Any JavaScript value.
     * @return {boolean} true if x is a transit big decimal, false otherwise.
     */
    transit.isBigDec = types.isBigDecimal;

    /**
     * Create transit keyword.
     * @method transit.keyword
     * @param {string} name A string.
     * @return {com.cognitect.transit.types.Keyword} A transit keyword.
     * @example
     *     transit.keyword("foo");
     */
    transit.keyword = types.keyword;

    /**
     * Test if an object is a transit keyword.
     * @method transit.isKeyword
     * @param {*} x
     *     Any JavaScript value.
     * @return {boolean} true if x is a transit keyword, false otherwise.
     */
    transit.isKeyword = types.isKeyword;

    /**
     * Create a transit symbol.
     * @method transit.symbol
     * @param {string} name
     *     A string.
     * @return {com.cognitect.transit.types.Symbol} A transit symbol instance.
     * @example
     *     transit.symbol("foo");
     */
    transit.symbol = types.symbol;

    /**
     * Test if an object is a transit symbol
     * @method transit.isSymbol
     * @param {*} x
     *     Any JavaScript value.
     * @return {boolean} true if x is a transit symbol, false otherwise.
     */
    transit.isSymbol = types.isSymbol;

    /**
     * Create transit binary blob.
     * @method transit.binary
     * @param {string} s
     *     A base64 encoded string.
     * @param {*=} decoder
     *     A Transit compliant decoder
     * @return {com.cognitect.transit.types.TaggedValue|Uint8Array} A transit binary blob instance.
     */
    transit.binary = types.binary;

    /**
     * Test if an object is a transit binary blob.
     * @method transit.isBinary
     * @param {*} x
     *     Any JavaScript value.
     * @return {Boolean} true if x is a binary value, false otheriwse.
     */
    transit.isBinary = types.isBinary;

    /**
     * Create a transit URI.
     * @method transit.uri
     * @param {string} s
     *     A string representing a valid URI.
     * @return {com.cognitect.transit.types.TaggedValue} A transit URI.
     */
    transit.uri = types.uri;

    /**
     * Test if an object is a transit URI.
     * @method transit.isURI
     * @param {*} x
     *     Any JavaScript value.
     * @return {Boolean} true if x is a transit symbol, false otherwise.
     */
    transit.isURI = types.isURI;

    /**
     * Create a transit hash map. Transit maps satisfy the current version
     *     of the ECMAScript 6 Map specification.
     * @method transit.map
     * @param {Array=} xs
     *     A JavaScript array of alternating key value pairs.
     * @return {com.cognitect.transit.MapLike} A transit map.
     * @example
     *     transit.map([new Date(), "foo", [1,2], 3]);
     */
    transit.map = types.map;

    /**
     * Test if an object is a transit map.
     * @method transit.isMap
     * @param {*} x
     *     Any JavaScript value.
     * @return {boolean} true if x is a transit map, false otherwise.
     */
    transit.isMap = types.isMap;

    /**
     * Create a transit set. Transit sets satisfy the current version of the
     *     of the ECMAScript 6 Set specification.
     * @method transit.set
     * @param {Array=} xs
     *     A JavaScript array of values.
     * @return {com.cognitect.transit.SetLike} A transit set.
     * @example
     *     transit.set(["foo", [1,2], 3, {bar: "baz"}]);
     */
    transit.set = types.set;

    /**
     * Test if an object is a transit set.
     * @method transit.isSet
     * @param {*} x
     *     Any JavaScript value.
     * @return {boolean} true if x is a transit set, false otherwise.
     */
    transit.isSet = types.isSet;

    /**
     * Create a transit list.
     * @method transit.list
     * @param {Array} xs
     *     A JavaScript array.
     * @return {com.cognitect.transit.types.TaggedValue} A transit list.
     */
    transit.list = types.list;

    /**
     * Test if an object is a transit list.
     * @method transit.isList
     * @param {*} x
     *     Any JavaScript value.
     * @return {boolean} true if x is a transit list, false otherwise.
     */
    transit.isList = types.isList;

    /**
     * Create a transit quoted value.
     * @method transit.quoted
     * @param {*} x
     *     Any JavaScript value.
     * @return {com.cognitect.transit.types.TaggedValue} A transit quoted value.
     */
    transit.quoted = types.quoted;

    /**
     * Test if an object is a transit quoted value.
     * @method transit.isQuoted
     * @param {*} x
     *     Any JavaScript value.
     * @return {boolean} true if x is a transit value, false otherwise.
     */
    transit.isQuoted = types.isQuoted;

    /**
     * Create a transit tagged value.
     * @method transit.tagged
     * @param {string} tag A tag.
     * @param {*} value
     *     A JavaScrpt array, object, or string.
     * @return {com.cognitect.transit.types.TaggedValue} A transit tagged value.
     * @example
     *     transit.tagged("point", new Point(1,2));
     */
    transit.tagged = types.taggedValue;

    /**
     * Test if an object is a transit tagged value.
     * @method transit.isTaggedValue
     * @param {*} x
     *     Any JavaScript value.
     * @return {boolean} true if x is a transit value, false otherwise.
     */
    transit.isTaggedValue =  types.isTaggedValue;

    /**
     * Create a transit link.
     * @method transit.link
     * @param {com.cognitect.transit.MapLike} m
     *     A transit map which must contain at a minimum the following keys:
     *     href, rel. It may optionally include name, render, and prompt. href
     *     must be a transit.uri, all other values are strings, and render must
     *     be either "image" or "link".
     * @return {Object} A transit link.
     */
    transit.link = types.link;

    /**
     * Test if an object is a transit link.
     * @method transit.isLink
     * @param {*} x
     *     Any JavaScript object.
     * @return {boolean} true if x is a transit link, false otherwise.
     */
    transit.isLink = types.isLink;

    /**
     * Compute the hashCode for any JavaScript object that has been
     *    extend to transit's equality and hashing protocol. JavaScript
     *    primitives and transit value are already extended to this protocol.
     *    Custom types may be extended to the protocol via transit.extenToEQ.
     * @method transit.hash
     * @param {*} x
     *    Any JavaScript object that has been extended to transit's equality
     *    and hashing protocol.
     * @return {number} Returns JavaScript number - semantically a 32bit integer.
     */
    transit.hash = eq.hashCode;

    /**
     * Compute the hashCode for JavaScript map-like types - either a JavaScript
     *    object or a JavaScript object that implements ES6 Map forEach.
     * @method transit.hashMapLike
     * @param {Object|com.cognitect.transit.MapLike} x
     *    A plain JavaScript Object or Object that implements ES6 Map forEach.
     * @return {number} Returns JavaScript number - semantically a 32bit integer.
     */
    transit.hashMapLike = eq.hashMapLike;

    /**
     * Compute the hashCode for JavaScript array-like types - either a JavaScript
     *    array or a JavaScript object that implements Array forEach.
     * @method transit.hashArrayLike
     * @param {Object} x
     *    A JavaScript Array or Object that implements Array forEach.
     * @return {number} Returns JavaScript number - semantically a 32bit integer.
     */
    transit.hashArrayLike = eq.hashArrayLike;

    /**
     * Test whether two JavaScript objects represent equal values. The
     *    objects to be tested should be extended to transit's equality
     *    and hasing protocol. JavaScript natives and transit value have
     *    already been extended to the protocol, including objects and
     *    arrays.  Also transit maps and JavaScript objects may be
     *    compared for equality. Custom types may be extended via
     *    transit.extendToEQ.
     * @param {*} x
     *     A JavaScript object
     * @param {*} y
     *     A JavaScript object
     * @return {Boolean} true if the x and y are equal, false otherwise.
     */
    transit.equals = eq.equals;

    /**
     * Extend an object to hashing and equality required by
     *     transit maps and sets. Only required for custom
     *     types, JavaScript primitive types and transit
     *     types are handled.
     * @method transit.extendToEQ
     * @param {*} x
     *     A JavaScript object, will be mutated.
     * @param {{hashCode: function(), equals: function(*,*):boolean}}
     *     A JavaScript object supplying `hashCode` and `equals`
     *     implementations
     * @return {*} x
     * @example
     *     transit.extendToEq(Point.protototype, {
     *         hashCode: function() {
     *             var bits = (this.x | 0) ^ ((this.y | 0) * 31);
     *             return bits ^ (bits >>> 32);
     *         },
     *         equals: function(other) {
     *             return this.x == other.x && this.y == other.y;
     *         }
     *     });
     */
    transit.extendToEQ = eq.extendToEQ;

    /**
     * Convert a transit map instance into a JavaScript Object.
     * Throws if the map has keys which have no string representation.
     * @method transit.mapToObject
     * @param {com.cognitect.transit.MapLike} m
     *     a transit map
     * @return {Object} a JavaScript Object
     */
    transit.mapToObject = function(m) {
        var ret = {};
        m.forEach(function(v, k) {
            if(typeof k !== "string") {
                throw Error("Cannot convert map with non-string keys");
            } else {
                ret[k] = v;
            }
        });
        return ret;
    };

    /**
     * Convert a POJO into a transit map.
     * @method transit.objectToMap
     * @param {Object} obj
     *     a JavaScript Object
     * @return {com.cognitect.transit.MapLike} a transit map
     */
    transit.objectToMap = function(obj) {
        var ret = transit.map();
        for(var p in obj) {
            if(obj.hasOwnProperty(p)) {
                ret.set(p, obj[p]);
            }
        }
        return ret;
    };

    /**
     * Construct a Transit JSON decoder.
     * @method transit.decoder
     * @param {Object} opts
     *     options to the decoder. Can include map of
     *     handlers.
     * @return {com.cognitect.transit.impl.decoder.Decoder} a Transit JSON decoder
     * @example
     *     var decoder = transit.decoder();
     *     var x = decoder.decode(json, transit.readCache());
     */
    transit.decoder = decoder.decoder;

    /**
     * Construct a Transit read cache
     * @method transit.readCache
     * @return {com.cognitect.transit.caching.ReadCache} a Transit read cache
     */
    transit.readCache = caching.readCache;

    /**
     * Construct a Transit write cache
     * @method transit.writeCache
     * @return {com.cognitect.transit.caching.WriteCache} a Transit write cache
     */
    transit.writeCache = caching.writeCache;

    transit.UUIDfromString = types.UUIDfromString;
    transit.randomUUID = util.randomUUID;
    transit.stringableKeys = writer.stringableKeys;

    if(TRANSIT_BROWSER_TARGET) {
        goog.exportSymbol("transit.reader",         transit.reader);
        goog.exportSymbol("transit.writer",         transit.writer);
        goog.exportSymbol("transit.makeBuilder",    transit.makeBuilder);
        goog.exportSymbol("transit.makeWriteHandler", transit.makeWriteHandler);
        goog.exportSymbol("transit.date",           types.date);
        goog.exportSymbol("transit.integer",        types.intValue);
        goog.exportSymbol("transit.isInteger",      types.isInteger);
        goog.exportSymbol("transit.uuid",           types.uuid);
        goog.exportSymbol("transit.isUUID",         types.isUUID);
        goog.exportSymbol("transit.bigInt",         types.bigInteger);
        goog.exportSymbol("transit.isBigInt",       types.isBigInteger);
        goog.exportSymbol("transit.bigDec",         types.bigDecimalValue);
        goog.exportSymbol("transit.isBigDec",       types.isBigDecimal);
        goog.exportSymbol("transit.keyword",        types.keyword);
        goog.exportSymbol("transit.isKeyword",      types.isKeyword);
        goog.exportSymbol("transit.symbol",         types.symbol);
        goog.exportSymbol("transit.isSymbol",       types.isSymbol);
        goog.exportSymbol("transit.binary",         types.binary);
        goog.exportSymbol("transit.isBinary",       types.isBinary);
        goog.exportSymbol("transit.uri",            types.uri);
        goog.exportSymbol("transit.isURI",          types.isURI);
        goog.exportSymbol("transit.map",            types.map);
        goog.exportSymbol("transit.isMap",          types.isMap);
        goog.exportSymbol("transit.set",            types.set);
        goog.exportSymbol("transit.isSet",          types.isSet);
        goog.exportSymbol("transit.list",           types.list);
        goog.exportSymbol("transit.isList",         types.isList);
        goog.exportSymbol("transit.quoted",         types.quoted);
        goog.exportSymbol("transit.isQuoted",       types.isQuoted);
        goog.exportSymbol("transit.tagged",         types.taggedValue);
        goog.exportSymbol("transit.isTaggedValue",  types.isTaggedValue);
        goog.exportSymbol("transit.link",           types.link);
        goog.exportSymbol("transit.isLink",         types.isLink);
        goog.exportSymbol("transit.hash",           eq.hashCode);
        goog.exportSymbol("transit.hashMapLike",    eq.hashMapLike);
        goog.exportSymbol("transit.hashArrayLike",  eq.hashArrayLike);
        goog.exportSymbol("transit.equals",         eq.equals);
        goog.exportSymbol("transit.extendToEQ",     eq.extendToEQ);
        goog.exportSymbol("transit.mapToObject",    transit.mapToObject);
        goog.exportSymbol("transit.objectToMap",    transit.objectToMap);
        goog.exportSymbol("transit.decoder",        decoder.decoder);
        goog.exportSymbol("transit.UUIDfromString", types.UUIDfromString);
        goog.exportSymbol("transit.randomUUID",     util.randomUUID);
        goog.exportSymbol("transit.stringableKeys", writer.stringableKeys);
        goog.exportSymbol("transit.readCache",      caching.readCache);
        goog.exportSymbol("transit.writeCache",     caching.writeCache);
    }

    if(TRANSIT_NODE_TARGET) {
        module.exports = {
            reader:         transit.reader,
            writer:         transit.writer,
            makeBuilder:    transit.makeBuilder,
            makeWriteHandler: transit.makeWriteHandler,
            date:           types.date,
            integer:        types.intValue,
            isInteger:      types.isInteger,
            uuid:           types.uuid,
            isUUID:         types.isUUID,
            bigInt:         types.bigInteger,
            isBigInt:       types.isBigInteger,
            bigDec:         types.bigDecimalValue,
            isBigDec:       types.isBigDecimal,
            keyword:        types.keyword,
            isKeyword:      types.isKeyword,
            symbol:         types.symbol,
            isSymbol:       types.isSymbol,
            binary:         types.binary,
            isBinary:       types.isBinary,
            uri:            types.uri,
            isURI:          types.isURI,
            map:            types.map,
            isMap:          types.isMap,
            set:            types.set,
            isSet:          types.isSet,
            list:           types.list,
            isList:         types.isList,
            quoted:         types.quoted,
            isQuoted:       types.isQuoted,
            tagged:         types.taggedValue,
            isTaggedValue:  types.isTaggedValue,
            link:           types.link,
            isLink:         types.isLink,
            hash:           eq.hashCode,
            hashArrayLike:  eq.hashArrayLike,
            hashMapLike:    eq.hashMapLike,
            equals:         eq.equals,
            extendToEQ:     eq.extendToEQ,
            mapToObject:    transit.mapToObject,
            objectToMap:    transit.objectToMap,
            decoder:        decoder.decoder,
            UUIDfromString: types.UUIDfromString,
            randomUUID:     util.randomUUID,
            stringableKeys: writer.stringableKeys,
            readCache:      caching.readCache,
            writeCache:     caching.writeCache
        };
    }
});