'use strict';

var fs          = require('fs');
var path        = require('path');
var assert      = require('assert');
var async       = require('asyncawait/async');
var await       = require('asyncawait/await');
var ipfsDaemon  = require('orbit-common/lib/ipfs-daemon');
var logger      = require('orbit-common/lib/logger');
var Server      = require('orbit-server/src/server');
var OrbitClient = require('../src/OrbitClient');

var serverConfig = {
  networkId: "orbitdb-test",
  networkName: "OrbitDB Test Network",
  salt: "hellothisisdog",
  userDataPath: "/tmp/orbitdb-tests",
  verifyMessages: true
}

// Orbit
const host     = 'localhost';
const port     = 3006;
const username = 'testrunner';
const password = '';

const startServer = async (() => {
  return new Promise(async((resolve, reject) => {
    logger.setLevel('ERROR');
    const ipfsd  = await(ipfsDaemon());
    const server = Server(ipfsd.daemon, ipfsd.nodeInfo, serverConfig);
    server.app.listen(port, () => {
      resolve(server);
    }).on('error', (err) => {
      resolve(server);
    });
  }));
});


describe('Orbit Client', () => {
  let server, orbit;

  let head    = '';
  let items   = [];
  let channel = 'abcdefgh';

  before(async((done) => {
    var initialize = () => new Promise(async((resolve, reject) => {
      orbit = OrbitClient.connect(`${host}:${port}`, username, password);
      orbit.channel(channel, '').delete();
      resolve();
    }));
    server = await(startServer());
    await(initialize());
    done();
  }));

  after(function(done) {
    var deleteChannel = () => new Promise(async((resolve, reject) => {
      if(orbit) orbit.channel(channel, '').delete();
      resolve();
    }));
    server.shutdown();
    server = null;
    deleteChannel().then(done);
  });

  /* TESTS */
  describe('Connect', function() {
    it('connects to hash-cache-server', async((done) => {
      assert.notEqual(orbit, null);
      assert.notEqual(orbit.client, null);
      assert.equal(orbit.user.id, 'Qmf5A5RSTQmcfvigT3j29Fqh2fAHRANk5ooBYKdWsPtr8U');
      assert.equal(orbit.network.id, serverConfig.networkId);
      assert.equal(orbit.network.name, serverConfig.networkName);
      assert.notEqual(orbit.network.config.SupernodeRouting, null);
      assert.notEqual(orbit.network.config.Bootstrap.length, 0);
      done();
    }));
  });

  describe('Info', function() {
    it('gets channel info on empty channel', async((done) => {
      var info = orbit.channel(channel, '').info();
      assert.notEqual(info, null);
      assert.equal(info.head, null);
      assert.notEqual(info.modes, null);
      done();
    }));

    it('gets channel info on an existing channel', async((done) => {
      var msg  = orbit.channel(channel, '').add('hello');
      var info = orbit.channel(channel, '').info();
      assert.notEqual(info, null);
      assert.notEqual(info.head, null);
      assert.notEqual(info.modes, null);
      assert.equal(info.modes.r, null);
      done();
    }));

    // it('gets channel info when channel has modes set', async((done) => {
    //   try {
    //     orbit.channel(channel).delete();
    //     var mode = {
    //       mode: "+r",
    //       params: {
    //         password: 'password'
    //       }
    //     };
    //     var res = orbit.channel(channel, '').setMode(mode)
    //     var info = orbit.channel(channel, 'password').info();
    //     assert.notEqual(info, null);
    //     assert.equal(info.head, null);
    //     assert.equal(JSON.stringify(info.modes), JSON.stringify(res));
    //     orbit.channel(channel, 'password').delete();
    //   } catch(e) {
    //     orbit.channel(channel, 'password').delete();
    //     assert.equal(e, null);
    //   }
    //   done();
    // }));

  });

  describe('Delete', function() {
    it('deletes a channel from the database', async((done) => {
      var result = orbit.channel(channel, '').delete();
      assert.equal(result, true);
      var iter = orbit.channel(channel, '').iterator();
      assert.equal(iter.next().value, null);
      done();
    }));

    it('deletes a channel with a password', async((done) => {
      done();
    }));

    it('doesn\'t delete a channel when password is wrong', async((done) => {
      done();
    }));

    it('doesn\'t delete a channel when user is not an op', async((done) => {
      done();
    }));
  });

  describe('Add events', function() {
    it('adds an item to an empty channel', async((done) => {
      try {
        orbit.channel(channel, '').delete();
        const head = orbit.channel(channel, '').add('hello');
        assert.notEqual(head, null);
        assert.equal(head.startsWith('Qm'), true);
        assert.equal(head.length, 46);
      } catch(e) {
        assert.equal(e, null);
      }
      done();
    }));

    it('adds a new item to a channel with one item', async((done) => {
      try {
        const head = orbit.channel(channel, '').iterator().collect()[0];
        const second = orbit.channel(channel, '').add('hello');
        assert.notEqual(second, null);
        assert.notEqual(second, head);
        assert.equal(second.startsWith('Qm'), true);
        assert.equal(second.length, 46);
      } catch(e) {
        assert.equal(e, null);
      }
      done();
    }));

    it('adds five items', async((done) => {
      for(var i = 0; i < 5; i ++) {
        try {
          var s = orbit.channel(channel, '').add('hello');
          assert.notEqual(s, null);
          assert.equal(s.startsWith('Qm'), true);
          assert.equal(s.length, 46);
        } catch(e) {
          assert.equal(e, null);
        }
      }
      done();
    }));

    it('adds an item that is > 256 bytes', async((done) => {
      try {
        var msg = new Buffer(512);
        msg.fill('a')
        var s = orbit.channel(channel, '').add(msg.toString());
        assert.notEqual(s, null);
        assert.equal(s.startsWith('Qm'), true);
        assert.equal(s.length, 46);
      } catch(e) {
        assert.equal(e, null);
      }
      done();
    }));
  });


  describe('Iterator', function() {
    var items = [];
    var itemCount = 5;

    before(function(done) {
      var addMessages = () => new Promise(async((resolve, reject) => {
        var result = orbit.channel(channel, '').delete();
        var iter   = orbit.channel(channel, '').iterator();
        for(var i = 0; i < itemCount; i ++) {
          var s = orbit.channel(channel, '').add('hello' + i);
          items.push(s);
        }
        resolve();
      }));
      addMessages().then(done);
    });

    describe('Defaults', function() {
      it('returns an iterator', async((done) => {
        var iter = orbit.channel(channel, '').iterator();
        var next = iter.next().value;
        assert.notEqual(iter, null);
        assert.notEqual(next, null);
        assert.notEqual(next.item, null);
        assert.notEqual(next.item.op, null);
        assert.equal(next.item.seq, 4);
        assert.notEqual(next.item.target, null);
        assert.notEqual(next.item.next, null);
        assert.notEqual(next.item.Payload, null);
        assert.equal(next.item.Payload, 'hello4');
        done();
      }));

      it('implements Iterator interface', async((done) => {
        var iter = orbit.channel(channel, '').iterator({ limit: -1 });
        var messages = [];

        for(let i of iter)
          messages.push(i.hash);

        assert.equal(messages.length, items.length);
        done();
      }));

      it('returns 1 item as default', async((done) => {
        var iter = orbit.channel(channel, '').iterator();
        var first = iter.next().value;
        var second = iter.next().value;
        assert.equal(first.item.key, items[items.length - 1]);
        assert.equal(second, null);
        assert.equal(first.item.Payload, 'hello4');
        done();
      }));
    });

    describe('Collect', function() {
      it('returns all items', async((done) => {
        var iter = orbit.channel(channel, '').iterator({ limit: -1 });
        var messages = iter.collect();
        assert.equal(messages.length, items.length);
        assert.equal(messages[messages.length - 1].item.Payload, 'hello0');
        assert.equal(messages[0].item.Payload, 'hello4');
        done();
      }));

      it('returns 1 item', async((done) => {
        var iter = orbit.channel(channel, '').iterator();
        var messages = iter.collect();
        assert.equal(messages.length, 1);
        done();
      }));

      it('returns 3 items', async((done) => {
        var iter = orbit.channel(channel, '').iterator({ limit: 3 });
        var messages = iter.collect();
        assert.equal(messages.length, 3);
        done();
      }));
    });

    describe('Options: limit', function() {
      it('returns 1 item when limit is 0', async((done) => {
        var iter = orbit.channel(channel, '').iterator({ limit: 0 });
        var first = iter.next().value;
        var second = iter.next().value;
        assert.equal(first.item.key, items[items.length - 1]);
        assert.equal(second, null);
        done();
      }));

      it('returns 1 item when limit is 1', async((done) => {
        var iter = orbit.channel(channel, '').iterator({ limit: 1 });
        var first = iter.next().value;
        var second = iter.next().value;
        assert.equal(first.item.key, items[items.length - 1]);
        assert.equal(second, null);
        done();
      }));

      it('returns 3 items', async((done) => {
        var iter = orbit.channel(channel, '').iterator({ limit: 3 });
        var first = iter.next().value;
        var second = iter.next().value;
        var third = iter.next().value;
        var fourth = iter.next().value;
        assert.equal(first.item.key, items[items.length - 1]);
        assert.equal(second.item.key, items[items.length - 2]);
        assert.equal(third.item.key, items[items.length - 3]);
        assert.equal(fourth, null);
        done();
      }));

      it('returns all items', async((done) => {
        var iter = orbit.channel(channel, '').iterator({ limit: -1 });
        var messages = iter.collect().map((e) => e.item.key);

        messages.reverse();
        assert.equal(messages.length, items.length);
        assert.equal(messages[0], items[0]);
        done();
      }));

      it('returns all items when limit is bigger than -1', async((done) => {
        var iter = orbit.channel(channel, '').iterator({ limit: -300 });
        var messages = iter.collect().map((e) => e.item.key);

        assert.equal(messages.length, items.length);
        assert.equal(messages[0], items[items.length - 1]);
        done();
      }));

      it('returns all items when limit is bigger than number of items', async((done) => {
        var iter = orbit.channel(channel, '').iterator({ limit: 300 });
        var messages = iter.collect().map((e) => e.item.key);

        assert.equal(messages.length, items.length);
        assert.equal(messages[0], items[items.length - 1]);
        done();
      }));
    });

    describe('Options: reverse', function() {
      it('returns all items reversed', async((done) => {
        var iter = orbit.channel(channel, '').iterator({ limit: -1, reverse: true });
        var messages = iter.collect().map((e) => e.item.key);

        assert.equal(messages.length, items.length);
        assert.equal(messages[0], items[0]);
        done();
      }));
    });

    describe('Options: ranges', function() {
      var all = [];
      var head;

      before((done) => {
        var fetchAll = () => new Promise(async((resolve, reject) => {
          all = orbit.channel(channel, '').iterator({ limit: -1 }).collect();
          head = all[0];
          resolve();
        }));
        fetchAll().then(done);
      });

      describe('gt & gte', function() {
        it('returns 0 items when gt is the head', async((done) => {
          var messages = orbit.channel(channel, '').iterator({ gt: head.hash }).collect();
          assert.equal(messages.length, 0);
          done();
        }));

        it('returns 1 item when gte is the head', async((done) => {
          var iter2 = orbit.channel(channel, '').iterator({ gte: head.hash, limit: -1 });
          var messages = iter2.collect().map((e) => e.item.key);

          assert.equal(messages.length, 1);
          assert.equal(messages[0], items[items.length -1]);
          done();
        }));

        it('returns 2 item when gte is defined', async((done) => {
          var gte = all[1].hash;
          var iter = orbit.channel(channel, '').iterator({ gte: gte, limit: -1 });
          var messages = iter.collect().map((e) => e.hash);

          assert.equal(messages.length, 2);
          assert.equal(messages[0], all[0].hash);
          assert.equal(messages[1], all[1].hash);
          done();
        }));

        it('returns all items when gte is the root item', async((done) => {
          var iter = orbit.channel(channel, '').iterator({ gte: all[all.length -1], limit: -1 });
          var messages = iter.collect().map((e) => e.item.key);

          assert.equal(messages.length, itemCount);
          assert.equal(messages[0], items[items.length - 1]);
          assert.equal(messages[messages.length - 1], items[0]);
          done();
        }));

        it('returns items when gt is the root item', async((done) => {
          var iter = orbit.channel(channel, '').iterator({ gt: all[all.length - 1], limit: -1 });
          var messages = iter.collect().map((e) => e.item.key);

          assert.equal(messages.length, itemCount - 1);
          assert.equal(messages[0], items[items.length - 1]);
          assert.equal(messages[3], items[1]);
          done();
        }));

        it('returns items when gt is defined', async((done) => {
          var iter = orbit.channel(channel, '').iterator({ limit: -1});
          var messages = iter.collect().map((e) => e.hash);

          var gt = messages[2];
          var iter2 = orbit.channel(channel, '').iterator({ gt: gt, limit: 100 });
          var messages2 = iter2.collect().map((e) => e.hash);

          assert.equal(messages2.length, 2);
          assert.equal(messages2[0], messages[0]);
          assert.equal(messages2[1], messages[1]);
          done();
        }));
      });

      describe('lt & lte', function() {
        it('returns one item when lt is the head', async((done) => {
          var iter2 = orbit.channel(channel, '').iterator({ lt: head.hash });
          var messages = iter2.collect().map((e) => e.hash);

          assert.equal(messages.length, 1);
          assert.equal(messages[0], head.hash);
          done();
        }));

        it('returns all items when lt is head and limit is -1', async((done) => {
          var iter2 = orbit.channel(channel, '').iterator({ lt: head.hash, limit: -1 });
          var messages = iter2.collect().map((e) => e.hash);

          assert.equal(messages.length, itemCount);
          assert.equal(messages[0], head.hash);
          assert.equal(messages[4], all[all.length - 1].hash);
          done();
        }));

        it('returns 3 items when lt is head and limit is 3', async((done) => {
          var iter2 = orbit.channel(channel, '').iterator({ lt: head.hash, limit: 3 });
          var messages = iter2.collect().map((e) => e.hash);

          assert.equal(messages.length, 3);
          assert.equal(messages[0], head.hash);
          assert.equal(messages[2], all[2].hash);
          done();
        }));

        it('returns null when lt is the root item', async((done) => {
          var messages = orbit.channel(channel, '').iterator({ lt: all[all.length - 1].hash }).collect();
          assert.equal(messages.length, 0);
          done();
        }));

        it('returns one item when lte is the root item', async((done) => {
          var iter = orbit.channel(channel, '').iterator({ lte: all[all.length - 1].hash });
          var messages = iter.collect().map((e) => e.hash);

          assert.equal(messages.length, 1);
          assert.equal(messages[0], all[all.length - 1].hash);
          done();
        }));

        it('returns all items when lte is the head', async((done) => {
          var iter2 = orbit.channel(channel, '').iterator({ lte: head.hash, limit: -1 });
          var messages = iter2.collect().map((e) => e.hash);

          assert.equal(messages.length, itemCount);
          assert.equal(messages[0], all[0].hash);
          assert.equal(messages[4], all[all.length - 1].hash);
          done();
        }));

        it('returns 3 items when lte is the head', async((done) => {
          var iter2 = orbit.channel(channel, '').iterator({ lte: head.hash, limit: 3 });
          var messages = iter2.collect().map((e) => e.hash);

          assert.equal(messages.length, 3);
          assert.equal(messages[0], all[0].hash);
          assert.equal(messages[1], all[1].hash);
          assert.equal(messages[2], all[2].hash);
          done();
        }));
      });
    });

  });


/*
  describe('Modes', function() {
    var password = 'hello';

    it('sets read mode', async((done) => {
      try {
        var mode = {
          mode: "+r",
          params: {
            password: password
          }
        };
        var modes = orbit.channel(channel, '').setMode(mode)
        assert.notEqual(modes.r, null);
        assert.equal(modes.r.password, password);
      } catch(e) {
        assert.equal(e, null);
      }
      done();
    }));

    it('can\'t read with wrong password', async((done) => {
      try {
        var modes = orbit.channel(channel, 'invalidpassword').iterator();
        assert.equal(true, false);
      } catch(e) {
        assert.equal(e, 'Unauthorized');
      }
      done();
    }));

    it('sets write mode', async((done) => {
      try {
        var mode = {
          mode: "+w",
          params: {
            ops: [orbit.user.id]
          }
        };
        var modes = orbit.channel(channel, password).setMode(mode);
        assert.notEqual(modes.w, null);
        assert.equal(modes.w.ops[0], orbit.user.id);
      } catch(e) {
        assert.equal(e, null);
      }
      done();
    }));

    it('can\'t write when user not an op', async((done) => {
      // TODO
      done();
    }));

    it('removes write mode', async((done) => {
      try {
        var modes = orbit.channel(channel, password).setMode({ mode: "-w" });
        assert.equal(modes.w, null);
      } catch(e) {
        assert.equal(e, null);
      }
      done();
    }));

    it('removes read mode', async((done) => {
      try {
        var modes = orbit.channel(channel, password).setMode({ mode: "-r" });
        assert.equal(modes.r, null);
      } catch(e) {
        assert.equal(e, null);
      }
      done();
    }));

  });
*/
});