/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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.
 */

// This is the Node.js test driver for the standard Apache Thrift
// test service. The driver invokes every function defined in the
// Thrift Test service with a representative range of parameters.
//
// The ThriftTestDriver function requires a client object
// connected to a server hosting the Thrift Test service and
// supports an optional callback function which is called with
// a status message when the test is complete.

import test = require("tape");
import ttypes = require("./gen-nodejs/ThriftTest_types");
import ThriftTest = require("./gen-nodejs/ThriftTest");
import thrift = require("thrift");
import TException = thrift.Thrift.TException;
var Int64 = require("node-int64");
import testCases = require("./test-cases");

export function ThriftTestDriver(
  client: ThriftTest.Client,
  callback: (status: string) => void,
) {
  test("NodeJS Style Callback Client Tests", function (assert) {
    var checkRecursively = makeRecursiveCheck(assert);

    function makeAsserter(assertionFn: (a: any, b: any, msg?: string) => void) {
      return function (c: (string | any)[]) {
        var fnName = c[0];
        var expected = c[1];
        (<any>client)[fnName](expected, function (err: any, actual: any) {
          assert.error(err, fnName + ": no callback error");
          assertionFn(actual, expected, fnName);
        });
      };
    }

    testCases.simple.forEach(makeAsserter(assert.equal));
    testCases.simpleLoose.forEach(
      makeAsserter(function (a, e, m) {
        assert.ok(a == e, m);
      }),
    );
    testCases.deep.forEach(makeAsserter(assert.deepEqual));

    client.testMapMap(42, function (err, response) {
      var expected: typeof response = {
        "4": { "1": 1, "2": 2, "3": 3, "4": 4 },
        "-4": { "-4": -4, "-3": -3, "-2": -2, "-1": -1 },
      };
      assert.error(err, "testMapMap: no callback error");
      assert.deepEqual(expected, response, "testMapMap");
    });

    client.testStruct(testCases.out, function (err, response) {
      assert.error(err, "testStruct: no callback error");
      checkRecursively(testCases.out, response, "testStruct");
    });

    client.testNest(testCases.out2, function (err, response) {
      assert.error(err, "testNest: no callback error");
      checkRecursively(testCases.out2, response, "testNest");
    });

    client.testInsanity(testCases.crazy, function (err, response) {
      assert.error(err, "testInsanity: no callback error");
      checkRecursively(testCases.insanity, response, "testInsanity");
    });

    client.testException("TException", function (err, response) {
      assert.ok(err instanceof TException, "testException: correct error type");
      assert.ok(!Boolean(response), "testException: no response");
    });

    client.testException("Xception", function (err, response) {
      assert.ok(
        err instanceof ttypes.Xception,
        "testException: correct error type",
      );
      assert.ok(!Boolean(response), "testException: no response");
      assert.equal(err.errorCode, 1001, "testException: correct error code");
      assert.equal(
        "Xception",
        err.message,
        "testException: correct error message",
      );
    });

    client.testException("no Exception", function (err, response) {
      assert.error(err, "testException: no callback error");
      assert.ok(!Boolean(response), "testException: no response");
    });

    client.testOneway(0, function (err, response) {
      assert.error(err, "testOneway: no callback error");
      assert.strictEqual(response, undefined, "testOneway: void response");
    });

    checkOffByOne(function (done) {
      client.testI32(-1, function (err, response) {
        assert.error(err, "checkOffByOne: no callback error");
        assert.equal(-1, response);
        assert.end();
        done();
      });
    }, callback);
  });
}

export function ThriftTestDriverPromise(
  client: ThriftTest.Client,
  callback: (status: string) => void,
) {
  test("Promise Client Tests", function (assert) {
    var checkRecursively = makeRecursiveCheck(assert);

    function fail(msg: string) {
      return function (error) {
        if (error !== null) {
          assert.fail(msg);
        }
      };
    }

    function makeAsserter(assertionFn: (a: any, b: any, msg?: string) => void) {
      return function (c: (string | any)[]) {
        var fnName = c[0];
        var expected = c[1];
        (<any>client)
          [fnName](expected)
          .then(function (actual: any) {
            assertionFn(actual, expected, fnName);
          })
          .catch(fail(fnName));
      };
    }

    testCases.simple.forEach(makeAsserter(assert.equal));
    testCases.simpleLoose.forEach(
      makeAsserter(function (a, e, m) {
        assert.ok(a == e, m);
      }),
    );
    testCases.deep.forEach(makeAsserter(assert.deepEqual));

    Promise.resolve(client.testStruct(testCases.out))
      .then(function (response) {
        checkRecursively(testCases.out, response, "testStruct");
      })
      .catch(fail("testStruct"));

    Promise.resolve(client.testNest(testCases.out2))
      .then(function (response) {
        checkRecursively(testCases.out2, response, "testNest");
      })
      .catch(fail("testNest"));

    Promise.resolve(client.testInsanity(testCases.crazy))
      .then(function (response) {
        checkRecursively(testCases.insanity, response, "testInsanity");
      })
      .catch(fail("testInsanity"));

    Promise.resolve(client.testException("TException"))
      .then(function (response) {
        assert.fail("testException: TException");
      })
      .catch(function (err) {
        assert.ok(err instanceof TException);
      });

    Promise.resolve(client.testException("Xception"))
      .then(function (response) {
        assert.fail("testException: Xception");
      })
      .catch(function (err) {
        assert.ok(err instanceof ttypes.Xception);
        assert.equal(err.errorCode, 1001);
        assert.equal("Xception", err.message);
      });

    Promise.resolve(client.testException("no Exception"))
      .then(function (response) {
        assert.equal(undefined, response); //void
      })
      .catch(fail("testException"));

    client.testOneway(0, fail("testOneway: should not answer"));

    checkOffByOne(function (done) {
      Promise.resolve(client.testI32(-1))
        .then(function (response) {
          assert.equal(-1, response);
          assert.end();
          done();
        })
        .catch(fail("checkOffByOne"));
    }, callback);
  });
}

// Helper Functions
// =========================================================

function makeRecursiveCheck(assert: test.Test) {
  return function (map1: any, map2: any, msg: string) {
    var equal = true;

    var equal = checkRecursively(map1, map2);

    assert.ok(equal, msg);

    // deepEqual doesn't work with fields using node-int64
    function checkRecursively(map1: any, map2: any): boolean {
      if (!(typeof map1 !== "function" && typeof map2 !== "function")) {
        return false;
      }
      if (!map1 || typeof map1 !== "object") {
        //Handle int64 types (which use node-int64 in Node.js JavaScript)
        if (
          typeof map1 === "number" &&
          typeof map2 === "object" &&
          map2.buffer &&
          map2.buffer instanceof Buffer &&
          map2.buffer.length === 8
        ) {
          var n = new Int64(map2.buffer);
          return map1 === n.toNumber();
        } else {
          return map1 == map2;
        }
      } else {
        return Object.keys(map1).every(function (key) {
          return checkRecursively(map1[key], map2[key]);
        });
      }
    }
  };
}

function checkOffByOne(
  done: (callback: () => void) => void,
  callback: (message: string) => void,
) {
  var retry_limit = 30;
  var retry_interval = 100;
  var test_complete = false;
  var retrys = 0;

  /**
   * redo a simple test after the oneway to make sure we aren't "off by one" --
   * if the server treated oneway void like normal void, this next test will
   * fail since it will get the void confirmation rather than the correct
   * result. In this circumstance, the client will throw the exception:
   *
   * Because this is the last test against the server, when it completes
   * the entire suite is complete by definition (the tests run serially).
   */
  done(function () {
    test_complete = true;
  });

  //We wait up to retry_limit * retry_interval for the test suite to complete
  function TestForCompletion() {
    if (test_complete && callback) {
      callback("Server successfully tested!");
    } else {
      if (++retrys < retry_limit) {
        setTimeout(TestForCompletion, retry_interval);
      } else if (callback) {
        callback(
          "Server test failed to complete after " +
            (retry_limit * retry_interval) / 1000 +
            " seconds",
        );
      }
    }
  }

  setTimeout(TestForCompletion, retry_interval);
}
