let assert = require('assert')
let spy = require('spy')
let ComicBook = require('../app/comic-book')
let srcs = [
    'data:image/gif;base64,R0lGODlhAQABAPAAAKqqqv///yH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==',
    'data:image/gif;base64,R0lGODlhAQABAPAAALu7u////yH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==',
    'data:image/gif;base64,R0lGODlhAQABAPAAAMzMzP///yH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==',
    'data:image/gif;base64,R0lGODlhAQABAPAAAN3d3f///yH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==',
    'data:image/gif;base64,R0lGODlhAQABAPAAAO7u7v///yH5BAAAAAAALAAAAAABAAEAAAICRAEAOw=='
  ]

describe('ComicBook', () => {

  describe('preload images', () => {

    it('should preload all given image srcs and emit preload:image, preload:finish events', done => {
      let comic = new ComicBook(srcs)
      let loaded = []

      comic.on('preload:image', image => loaded.push(image.src))

      comic.on('preload:finish', () => {
        assert.deepEqual(loaded, srcs, 'all requested images should have been loaded')
        done()
      })

      comic.preload()
    })

    it('should only load a given amount of images at a time')

    it('should preload images in both directions')

    it('should emit a preload:start event', done => {
      let comic = new ComicBook(srcs)

      comic.on('preload:start', () => done())

      comic.preload()
    })

    it('should emit a preload:ready event', done => {
      let comic = new ComicBook(srcs)

      comic.preloadBuffer = 2

      comic.on('preload:ready', () => {
        assert.equal(comic.pages.size, 2)
        done()
      })

      comic.preload()
    })

    it('preload:ready should make sure that double page mode can show two images')

    it('should show the load indicator on preload:start', done => {
      let comic = new ComicBook(srcs)
      assert.equal(comic.loadIndicator.el.style.display, 'none')
      comic.loadIndicator.on('show', () => done())
      comic.preload()
    })

    it('should show the progress bar on preload:start', () => {
      let comic = new ComicBook(srcs)
      assert.equal(comic.progressBar.el.style.display, 'none')
      comic.preload()
      assert.equal(comic.progressBar.el.style.display, 'block')
    })

    it('should update the progress bar', done => {
      let comic = new ComicBook(srcs)

      comic.progressBar.update = spy()
      comic.preload()

      comic.on('preload:finish', () => {
        assert.equal(comic.progressBar.update.callCount, 5)
        assert(comic.progressBar.update.calls[0].calledWith(20))
        assert(comic.progressBar.update.calls[1].calledWith(40))
        assert(comic.progressBar.update.calls[2].calledWith(60))
        assert(comic.progressBar.update.calls[3].calledWith(80))
        assert(comic.progressBar.update.calls[4].calledWith(100))
        done()
      })
    })

    it('should hide the progress bar when finished', done => {
      let comic = new ComicBook(srcs)

      comic.preload()

      comic.on('preload:finish', () => {
        assert.equal(comic.progressBar.el.style.display, 'none')
        done()
      })
    })

    it('should restart the preload from whatever page is requested')
  })

  describe('draw', () => {

    describe('drawPage()', () => {

      it('should draw a given page', () => {
        let comic = new ComicBook(srcs)

        comic.canvas.drawImage = spy()

        comic.drawPage(1)

        assert.equal(comic.canvas.drawImage.callCount, 1)
        assert(comic.canvas.drawImage.calls[0].calledWith(comic.pages.get(1)))
      })

      it('should default to drawing the current page', () => {
        let comic = new ComicBook(srcs)

        comic.canvas.drawImage = spy()
        comic.currentPageIndex = 2

        comic.drawPage()

        assert.equal(comic.canvas.drawImage.callCount, 1)
        assert(comic.canvas.drawImage.calls[0].calledWith(comic.pages.get(2)))
      })

      it('should update the current page index after drawing', () => {
        let comic = new ComicBook(srcs)

        comic.canvas.drawImage = () => {}
        comic.currentPageIndex = 1

        comic.drawPage(2)

        assert.equal(comic.currentPageIndex, 2)
      })

      it('should ignore "Invalid image" exceptions and not draw the page when they occur', () => {
        let comic = new ComicBook(srcs)

        comic.currentPageIndex = 1

        assert.doesNotThrow(comic.drawPage.bind(comic, 666))
        assert.equal(comic.currentPageIndex, 1)
      })

      it('should throw all other exceptions and not draw the page when they occur', () => {
        let comic = new ComicBook(srcs)

        comic.canvas.drawImage = () => { throw new Error('Some other exception') }

        assert.throws(comic.drawPage.bind(comic))
      })

      it('should draw two pages in double page mode')
    })

    describe('drawNextPage()', () => {

      it('should draw the next page', done => {
        let comic = new ComicBook(srcs)

        comic.drawPage = spy()
        comic.currentPageIndex = 1

        comic.on('preload:finish', () => {
          comic.drawNextPage()
          assert(comic.drawPage.calls[0].calledWith(2))
          done()
        })

        comic.preload()
      })

      it('should draw the next page in double page mode', done => {
        let comic = new ComicBook(srcs)

        comic.drawPage = spy()
        comic.currentPageIndex = 1
        comic.options.doublePage = true

        comic.on('preload:finish', () => {
          comic.drawNextPage()
          assert(comic.drawPage.calls[0].calledWith(3))
          done()
        })

        comic.preload()
      })

      it('should handle the final page of double page mode being a single page', done => {
        let comic = new ComicBook(srcs)

        comic.drawPage = spy()
        comic.currentPageIndex = 3
        comic.options.doublePage = true

        comic.on('preload:finish', () => {
          comic.drawNextPage()
          assert(comic.drawPage.calls[0].calledWith(4))
          done()
        })

        comic.preload()
      })
    })

    describe('drawPreviousPage()', () => {

      it('should draw the previous page', done => {
        let comic = new ComicBook(srcs)

        comic.drawPage = spy()
        comic.currentPageIndex = 2

        comic.on('preload:finish', () => {
          comic.drawPreviousPage()
          assert(comic.drawPage.calls[0].calledWith(1))
          done()
        })

        comic.preload()
      })

      it('should draw the previous page in double page mode', done => {
        let comic = new ComicBook(srcs)

        comic.drawPage = spy()
        comic.currentPageIndex = 3
        comic.options.doublePage = true

        comic.on('preload:finish', () => {
          comic.drawPreviousPage()
          assert(comic.drawPage.calls[0].calledWith(1))
          done()
        })

        comic.preload()
      })

      it('should handle navigating back to an uneven first page in double page mode', done => {
        let comic = new ComicBook(srcs)

        comic.drawPage = spy()
        comic.currentPageIndex = 1
        comic.options.doublePage = true

        comic.on('preload:finish', () => {
          comic.drawPreviousPage()
          assert(comic.drawPage.calls[0].calledWith(0))
          done()
        })

        comic.preload()
      })

      it('should reverse image order in double page manga mode')
    })
  })

  describe('routing', () => {

    it('should scroll to the top of the page on page turn')

    it('should render a page when the route changes')
  })

})