import * as assert from 'assert'
import {Counter} from 'automerge'
import * as Automerge from '../src'
import * as WASM from "@automerge/automerge-wasm"

describe('Automerge', () => {
    describe('basics', () => {
        it('should init clone and free', () => {
            let doc1 = Automerge.init()
            let doc2 = Automerge.clone(doc1);

            // this is only needed if weakrefs are not supported
            Automerge.free(doc1)
            Automerge.free(doc2)
        })

        it('should be able to make a view with specifc heads', () => {
            let doc1 = Automerge.init()
            let doc2 = Automerge.change(doc1, (d) => d.value = 1)
            let heads2 = Automerge.getHeads(doc2)
            let doc3 = Automerge.change(doc2, (d) => d.value = 2)
            let doc2_v2 = Automerge.view(doc3, heads2)
            assert.deepEqual(doc2, doc2_v2)
            let doc2_v2_clone = Automerge.clone(doc2, "aabbcc")
            assert.deepEqual(doc2, doc2_v2_clone)
            assert.equal(Automerge.getActorId(doc2_v2_clone), "aabbcc")
        })

        it("should allow you to change a clone of a view", () => {
            let doc1 = Automerge.init<any>()
            doc1 = Automerge.change(doc1, d => d.key = "value")
            let heads = Automerge.getHeads(doc1)
            doc1 = Automerge.change(doc1, d => d.key = "value2")
            let fork = Automerge.clone(Automerge.view(doc1, heads))
            assert.deepEqual(fork, {key: "value"})
            fork = Automerge.change(fork, d => d.key = "value3")
            assert.deepEqual(fork, {key: "value3"})
        })

        it('handle basic set and read on root object', () => {
            let doc1 = Automerge.init()
            let doc2 = Automerge.change(doc1, (d) => {
              d.hello = "world"
              d.big = "little"
              d.zip = "zop"
              d.app = "dap"
              assert.deepEqual(d, {  hello: "world", big: "little", zip: "zop", app: "dap" })
            })
            assert.deepEqual(doc2, {  hello: "world", big: "little", zip: "zop", app: "dap" })
        })

        it('can detect an automerge doc with isAutomerge()', () => {
            const doc1 = Automerge.from({ sub: { object: true } })
            assert(Automerge.isAutomerge(doc1))
            assert(!Automerge.isAutomerge(doc1.sub))
            assert(!Automerge.isAutomerge("String"))
            assert(!Automerge.isAutomerge({ sub: { object: true }}))
            assert(!Automerge.isAutomerge(undefined))
            const jsObj = Automerge.toJS(doc1)
            assert(!Automerge.isAutomerge(jsObj))
            assert.deepEqual(jsObj, doc1)
        })

        it('it should recursively freeze the document if requested', () => {
            let doc1 = Automerge.init({ freeze: true } )
            let doc2 = Automerge.init()

            assert(Object.isFrozen(doc1))
            assert(!Object.isFrozen(doc2))

            // will also freeze sub objects
            doc1 = Automerge.change(doc1, (doc) => doc.book = { title: "how to win friends" })
            doc2 = Automerge.merge(doc2,doc1)
            assert(Object.isFrozen(doc1))
            assert(Object.isFrozen(doc1.book))
            assert(!Object.isFrozen(doc2))
            assert(!Object.isFrozen(doc2.book))

            // works on from
            let doc3 = Automerge.from({ sub: { obj: "inner" } }, { freeze: true })
            assert(Object.isFrozen(doc3))
            assert(Object.isFrozen(doc3.sub))

            // works on load
            let doc4 = Automerge.load(Automerge.save(doc3), { freeze: true })
            assert(Object.isFrozen(doc4))
            assert(Object.isFrozen(doc4.sub))

            // follows clone
            let doc5 = Automerge.clone(doc4)
            assert(Object.isFrozen(doc5))
            assert(Object.isFrozen(doc5.sub))

            // toJS does not freeze
            let exported = Automerge.toJS(doc5)
            assert(!Object.isFrozen(exported))
        })

        it('handle basic sets over many changes', () => {
            let doc1 = Automerge.init()
            let timestamp = new Date();
            let counter = new Automerge.Counter(100);
            let bytes = new Uint8Array([10,11,12]);
            let doc2 = Automerge.change(doc1, (d) => {
              d.hello = "world"
            })
            let doc3 = Automerge.change(doc2, (d) => {
              d.counter1 = counter
            })
            let doc4 = Automerge.change(doc3, (d) => {
              d.timestamp1 = timestamp
            })
            let doc5 = Automerge.change(doc4, (d) => {
              d.app = null
            })
            let doc6 = Automerge.change(doc5, (d) => {
              d.bytes1 = bytes
            })
            let doc7 = Automerge.change(doc6, (d) => {
              d.uint = new Automerge.Uint(1)
              d.int = new Automerge.Int(-1)
              d.float64 = new Automerge.Float64(5.5)
              d.number1 = 100
              d.number2 = -45.67
              d.true = true
              d.false = false
            })

            assert.deepEqual(doc7, {  hello: "world", true: true, false: false, int: -1, uint: 1, float64: 5.5, number1: 100, number2: -45.67, counter1: counter, timestamp1: timestamp, bytes1: bytes, app: null })

            let changes = Automerge.getAllChanges(doc7)
            let t1 = Automerge.init()
            ;let [t2] = Automerge.applyChanges(t1, changes)
            assert.deepEqual(doc7,t2)
        })

        it('handle overwrites to values', () => {
            let doc1 = Automerge.init()
            let doc2 = Automerge.change(doc1, (d) => {
              d.hello = "world1"
            })
            let doc3 = Automerge.change(doc2, (d) => {
              d.hello = "world2"
            })
            let doc4 = Automerge.change(doc3, (d) => {
              d.hello = "world3"
            })
            let doc5 = Automerge.change(doc4, (d) => {
              d.hello = "world4"
            })
            assert.deepEqual(doc5, {  hello: "world4" } )
        })

        it('handle set with object value', () => {
            let doc1 = Automerge.init()
            let doc2 = Automerge.change(doc1, (d) => {
              d.subobj = { hello: "world", subsubobj: { zip: "zop" } }
            })
            assert.deepEqual(doc2, { subobj:  { hello: "world", subsubobj: { zip: "zop" } } })
        })

        it('handle simple list creation', () => {
            let doc1 = Automerge.init()
            let doc2 = Automerge.change(doc1, (d) => d.list = [])
            assert.deepEqual(doc2, { list: []})
        })

        it('handle simple lists', () => {
            let doc1 = Automerge.init()
            let doc2 = Automerge.change(doc1, (d) => {
              d.list = [ 1, 2, 3 ]
            })
            assert.deepEqual(doc2.list.length, 3)
            assert.deepEqual(doc2.list[0], 1)
            assert.deepEqual(doc2.list[1], 2)
            assert.deepEqual(doc2.list[2], 3)
            assert.deepEqual(doc2, { list: [1,2,3] })
           // assert.deepStrictEqual(Automerge.toJS(doc2), { list: [1,2,3] })

            let doc3 = Automerge.change(doc2, (d) => {
              d.list[1] = "a"
            })

            assert.deepEqual(doc3.list.length, 3)
            assert.deepEqual(doc3.list[0], 1)
            assert.deepEqual(doc3.list[1], "a")
            assert.deepEqual(doc3.list[2], 3)
            assert.deepEqual(doc3, { list: [1,"a",3] })
        })
        it('handle simple lists', () => {
            let doc1 = Automerge.init()
            let doc2 = Automerge.change(doc1, (d) => {
              d.list = [ 1, 2, 3 ]
            })
            let changes = Automerge.getChanges(doc1, doc2)
            let docB1 = Automerge.init()
            ;let [docB2] = Automerge.applyChanges(docB1, changes)
            assert.deepEqual(docB2, doc2);
        })
        it('handle text', () => {
            let doc1 = Automerge.init()
            let doc2 = Automerge.change(doc1, (d) => {
              d.list = "hello"
              Automerge.splice(d, "list", 2, 0, "Z")
            })
            let changes = Automerge.getChanges(doc1, doc2)
            let docB1 = Automerge.init()
            ;let [docB2] = Automerge.applyChanges(docB1, changes)
            assert.deepEqual(docB2, doc2);
        })

        it('handle non-text strings', () => {
            let doc1 = WASM.create();
            doc1.put("_root", "text", "hello world");
            let doc2 = Automerge.load(doc1.save())
            assert.throws(() => {
              Automerge.change(doc2, (d) => { Automerge.splice(d, "text", 1, 0, "Z") })
            }, /Cannot splice/)
        })

        it('have many list methods', () => {
            let doc1 = Automerge.from({ list: [1,2,3] })
            assert.deepEqual(doc1, { list: [1,2,3] });
            let doc2 = Automerge.change(doc1, (d) => {
              d.list.splice(1,1,9,10)
            })
            assert.deepEqual(doc2, { list: [1,9,10,3] });
            let doc3 = Automerge.change(doc2, (d) => {
              d.list.push(11,12)
            })
            assert.deepEqual(doc3, { list: [1,9,10,3,11,12] });
            let doc4 = Automerge.change(doc3, (d) => {
              d.list.unshift(2,2)
            })
            assert.deepEqual(doc4, { list: [2,2,1,9,10,3,11,12] });
            let doc5 = Automerge.change(doc4, (d) => {
              d.list.shift()
            })
            assert.deepEqual(doc5, { list: [2,1,9,10,3,11,12] });
            let doc6 = Automerge.change(doc5, (d) => {
              d.list.insertAt(3,100,101)
            })
            assert.deepEqual(doc6, { list: [2,1,9,100,101,10,3,11,12] });
        })

        it('allows access to the backend', () => {
          let doc = Automerge.init()
          assert.deepEqual(Object.keys(Automerge.getBackend(doc)), ["ptr"])
        })

        it('lists and text have indexof', () => {
          let doc = Automerge.from({ list: [0,1,2,3,4,5,6], text: "hello world" })
          console.log(doc.list.indexOf(5))
          console.log(doc.text.indexOf("world"))
        })
    })

    describe('emptyChange', () => {
        it('should generate a hash', () => {
            let doc = Automerge.init()
            doc = Automerge.change<any>(doc, d => {
                d.key = "value"
            })
            let _ = Automerge.save(doc)
            let headsBefore = Automerge.getHeads(doc)
            headsBefore.sort()
            doc = Automerge.emptyChange(doc, "empty change")
            let headsAfter = Automerge.getHeads(doc)
            headsAfter.sort()
            assert.notDeepEqual(headsBefore, headsAfter)
        })
    })

    describe('proxy lists', () => {
        it('behave like arrays', () => {
          let doc = Automerge.from({
            chars: ["a","b","c"],
            numbers: [20,3,100],
            repeats: [20,20,3,3,3,3,100,100]
          })
          let r1 = []
          doc = Automerge.change(doc, (d) => {
            assert.deepEqual(d.chars.concat([1,2]), ["a","b","c",1,2])
            assert.deepEqual(d.chars.map((n) => n + "!"), ["a!", "b!", "c!"])
            assert.deepEqual(d.numbers.map((n) => n + 10), [30, 13, 110])
            assert.deepEqual(d.numbers.toString(), "20,3,100")
            assert.deepEqual(d.numbers.toLocaleString(), "20,3,100")
            assert.deepEqual(d.numbers.forEach((n) => r1.push(n)), undefined)
            assert.deepEqual(d.numbers.every((n) => n > 1), true)
            assert.deepEqual(d.numbers.every((n) => n > 10), false)
            assert.deepEqual(d.numbers.filter((n) => n > 10), [20,100])
            assert.deepEqual(d.repeats.find((n) => n < 10), 3)
            assert.deepEqual(d.repeats.toArray().find((n) => n < 10), 3)
            assert.deepEqual(d.repeats.find((n) => n < 0), undefined)
            assert.deepEqual(d.repeats.findIndex((n) => n < 10), 2)
            assert.deepEqual(d.repeats.findIndex((n) => n < 0), -1)
            assert.deepEqual(d.repeats.toArray().findIndex((n) => n < 10), 2)
            assert.deepEqual(d.repeats.toArray().findIndex((n) => n < 0), -1)
            assert.deepEqual(d.numbers.includes(3), true)
            assert.deepEqual(d.numbers.includes(-3), false)
            assert.deepEqual(d.numbers.join("|"), "20|3|100")
            assert.deepEqual(d.numbers.join(), "20,3,100")
            assert.deepEqual(d.numbers.some((f) => f === 3), true)
            assert.deepEqual(d.numbers.some((f) => f < 0), false)
            assert.deepEqual(d.numbers.reduce((sum,n) => sum + n, 100), 223)
            assert.deepEqual(d.repeats.reduce((sum,n) => sum + n, 100), 352)
            assert.deepEqual(d.chars.reduce((sum,n) => sum + n, "="), "=abc")
            assert.deepEqual(d.chars.reduceRight((sum,n) => sum + n, "="), "=cba")
            assert.deepEqual(d.numbers.reduceRight((sum,n) => sum + n, 100), 223)
            assert.deepEqual(d.repeats.lastIndexOf(3), 5)
            assert.deepEqual(d.repeats.lastIndexOf(3,3), 3)
          })
          doc = Automerge.change(doc, (d) => {
            assert.deepEqual(d.numbers.fill(-1,1,2), [20,-1,100])
            assert.deepEqual(d.chars.fill("z",1,100), ["a","z","z"])
          })
          assert.deepEqual(r1, [20,3,100])
          assert.deepEqual(doc.numbers, [20,-1,100])
          assert.deepEqual(doc.chars, ["a","z","z"])
        })
    })
    
    it('should obtain the same conflicts, regardless of merge order', () => {
      let s1 = Automerge.init()
      let s2 = Automerge.init()
      s1 = Automerge.change(s1, doc => { doc.x = 1; doc.y = 2 })
      s2 = Automerge.change(s2, doc => { doc.x = 3; doc.y = 4 })
      const m1 = Automerge.merge(Automerge.clone(s1), Automerge.clone(s2))
      const m2 = Automerge.merge(Automerge.clone(s2), Automerge.clone(s1))
      assert.deepStrictEqual(Automerge.getConflicts(m1, 'x'), Automerge.getConflicts(m2, 'x'))
    })

    describe("getObjectId", () => {
        let s1 = Automerge.from({
            "string": "string",
            "number": 1,
            "null": null,
            "date": new Date(),
            "counter": new Automerge.Counter(),
            "bytes": new Uint8Array(10),
            "text": "",
            "list": [],
            "map": {}
        })

        it("should return null for scalar values", () => {
            assert.equal(Automerge.getObjectId(s1.string), null)
            assert.equal(Automerge.getObjectId(s1.number), null)
            assert.equal(Automerge.getObjectId(s1.null), null)
            assert.equal(Automerge.getObjectId(s1.date), null)
            assert.equal(Automerge.getObjectId(s1.counter), null)
            assert.equal(Automerge.getObjectId(s1.bytes), null)
        })

        it("should return _root for the root object", () => {
            assert.equal(Automerge.getObjectId(s1), "_root")
        })

        it("should return non-null for map, list, text, and objects", () => {
            assert.equal(Automerge.getObjectId(s1.text), null)
            assert.notEqual(Automerge.getObjectId(s1.list), null)
            assert.notEqual(Automerge.getObjectId(s1.map), null)
        })
    })
})