'use strict'

const Panel = require('../src/panel')
const PanelContainer = require('../src/panel-container')

describe('PanelContainer', () => {
  let container

  class TestPanelItem {
  }

  beforeEach(() => {
    container = new PanelContainer({viewRegistry: atom.views})
  })

  describe('::addPanel(panel)', () => {
    it('emits an onDidAddPanel event with the index the panel was inserted at', () => {
      const addPanelSpy = jasmine.createSpy()
      container.onDidAddPanel(addPanelSpy)

      const panel1 = new Panel({item: new TestPanelItem()}, atom.views)
      container.addPanel(panel1)
      expect(addPanelSpy).toHaveBeenCalledWith({panel: panel1, index: 0})

      const panel2 = new Panel({item: new TestPanelItem()}, atom.views)
      container.addPanel(panel2)
      expect(addPanelSpy).toHaveBeenCalledWith({panel: panel2, index: 1})
    })
  })

  describe('when a panel is destroyed', () => {
    it('emits an onDidRemovePanel event with the index of the removed item', () => {
      const removePanelSpy = jasmine.createSpy()
      container.onDidRemovePanel(removePanelSpy)

      const panel1 = new Panel({item: new TestPanelItem()}, atom.views)
      container.addPanel(panel1)
      const panel2 = new Panel({item: new TestPanelItem()}, atom.views)
      container.addPanel(panel2)

      expect(removePanelSpy).not.toHaveBeenCalled()

      panel2.destroy()
      expect(removePanelSpy).toHaveBeenCalledWith({panel: panel2, index: 1})

      panel1.destroy()
      expect(removePanelSpy).toHaveBeenCalledWith({panel: panel1, index: 0})
    })
  })

  describe('::destroy()', () => {
    it('destroys the container and all of its panels', () => {
      const destroyedPanels = []

      const panel1 = new Panel({item: new TestPanelItem()}, atom.views)
      panel1.onDidDestroy(() => { destroyedPanels.push(panel1) })
      container.addPanel(panel1)

      const panel2 = new Panel({item: new TestPanelItem()}, atom.views)
      panel2.onDidDestroy(() => { destroyedPanels.push(panel2) })
      container.addPanel(panel2)

      container.destroy()

      expect(container.getPanels().length).toBe(0)
      expect(destroyedPanels).toEqual([panel1, panel2])
    })
  })

  describe('panel priority', () => {
    describe('left / top panel container', () => {
      let initialPanel
      beforeEach(() => {
        // 'left' logic is the same as 'top'
        container = new PanelContainer({location: 'left'})
        initialPanel = new Panel({item: new TestPanelItem()}, atom.views)
        container.addPanel(initialPanel)
      })

      describe('when a panel with low priority is added', () => {
        it('is inserted at the beginning of the list', () => {
          const addPanelSpy = jasmine.createSpy()
          container.onDidAddPanel(addPanelSpy)
          const panel = new Panel({item: new TestPanelItem(), priority: 0}, atom.views)
          container.addPanel(panel)

          expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0})
          expect(container.getPanels()[0]).toBe(panel)
        })
      })

      describe('when a panel with priority between two other panels is added', () => {
        it('is inserted at the between the two panels', () => {
          const addPanelSpy = jasmine.createSpy()
          let panel = new Panel({item: new TestPanelItem(), priority: 1000}, atom.views)
          container.addPanel(panel)

          container.onDidAddPanel(addPanelSpy)
          panel = new Panel({item: new TestPanelItem(), priority: 101}, atom.views)
          container.addPanel(panel)

          expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 1})
          expect(container.getPanels()[1]).toBe(panel)
        })
      })
    })

    describe('right / bottom panel container', () => {
      let initialPanel
      beforeEach(() => {
        // 'bottom' logic is the same as 'right'
        container = new PanelContainer({location: 'right'})
        initialPanel = new Panel({item: new TestPanelItem()}, atom.views)
        container.addPanel(initialPanel)
      })

      describe('when a panel with high priority is added', () => {
        it('is inserted at the beginning of the list', () => {
          const addPanelSpy = jasmine.createSpy()
          container.onDidAddPanel(addPanelSpy)
          const panel = new Panel({item: new TestPanelItem(), priority: 1000}, atom.views)
          container.addPanel(panel)

          expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 0})
          expect(container.getPanels()[0]).toBe(panel)
        })
      })

      describe('when a panel with low priority is added', () => {
        it('is inserted at the end of the list', () => {
          const addPanelSpy = jasmine.createSpy()
          container.onDidAddPanel(addPanelSpy)
          const panel = new Panel({item: new TestPanelItem(), priority: 0}, atom.views)
          container.addPanel(panel)

          expect(addPanelSpy).toHaveBeenCalledWith({panel, index: 1})
          expect(container.getPanels()[1]).toBe(panel)
        })
      })
    })
  })
})