const { extend } = require('underscore-plus')
const { Emitter } = require('event-kit')
const Grim = require('grim')
const Pane = require('../src/pane')
const PaneContainer = require('../src/pane-container')
const { conditionPromise, timeoutPromise } = require('./async-spec-helpers')

describe('Pane', () => {
  let confirm, showSaveDialog, deserializerDisposable

  class Item {
    static deserialize ({ name, uri }) {
      return new Item(name, uri)
    }

    constructor (name, uri) {
      this.name = name
      this.uri = uri
      this.emitter = new Emitter()
      this.destroyed = false
    }

    getURI () {
      return this.uri
    }
    getPath () {
      return this.path
    }
    isEqual (other) {
      return this.name === (other && other.name)
    }
    isPermanentDockItem () {
      return false
    }
    isDestroyed () {
      return this.destroyed
    }

    serialize () {
      return { deserializer: 'Item', name: this.name, uri: this.uri }
    }

    copy () {
      return new Item(this.name, this.uri)
    }

    destroy () {
      this.destroyed = true
      return this.emitter.emit('did-destroy')
    }

    onDidDestroy (fn) {
      return this.emitter.on('did-destroy', fn)
    }

    onDidTerminatePendingState (callback) {
      return this.emitter.on('terminate-pending-state', callback)
    }

    terminatePendingState () {
      return this.emitter.emit('terminate-pending-state')
    }
  }

  beforeEach(() => {
    confirm = spyOn(atom.applicationDelegate, 'confirm')
    showSaveDialog = spyOn(atom.applicationDelegate, 'showSaveDialog')
    deserializerDisposable = atom.deserializers.add(Item)
  })

  afterEach(() => {
    deserializerDisposable.dispose()
  })

  function paneParams (params) {
    return extend(
      {
        applicationDelegate: atom.applicationDelegate,
        config: atom.config,
        deserializerManager: atom.deserializers,
        notificationManager: atom.notifications
      },
      params
    )
  }

  describe('construction', () => {
    it('sets the active item to the first item', () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B')] })
      )
      expect(pane.getActiveItem()).toBe(pane.itemAtIndex(0))
    })

    it('compacts the items array', () => {
      const pane = new Pane(
        paneParams({ items: [undefined, new Item('A'), null, new Item('B')] })
      )
      expect(pane.getItems().length).toBe(2)
      expect(pane.getActiveItem()).toBe(pane.itemAtIndex(0))
    })
  })

  describe('::activate()', () => {
    let container, pane1, pane2

    beforeEach(() => {
      container = new PaneContainer({
        location: 'center',
        config: atom.config,
        applicationDelegate: atom.applicationDelegate
      })
      container.getActivePane().splitRight()
      ;[pane1, pane2] = container.getPanes()
    })

    it('changes the active pane on the container', () => {
      expect(container.getActivePane()).toBe(pane2)
      pane1.activate()
      expect(container.getActivePane()).toBe(pane1)
      pane2.activate()
      expect(container.getActivePane()).toBe(pane2)
    })

    it('invokes ::onDidChangeActivePane observers on the container', () => {
      const observed = []
      container.onDidChangeActivePane(activePane => observed.push(activePane))

      pane1.activate()
      pane1.activate()
      pane2.activate()
      pane1.activate()
      expect(observed).toEqual([pane1, pane2, pane1])
    })

    it('invokes ::onDidChangeActive observers on the relevant panes', () => {
      const observed = []
      pane1.onDidChangeActive(active => observed.push(active))
      pane1.activate()
      pane2.activate()
      expect(observed).toEqual([true, false])
    })

    it('invokes ::onDidActivate() observers', () => {
      let eventCount = 0
      pane1.onDidActivate(() => eventCount++)
      pane1.activate()
      pane1.activate()
      pane2.activate()
      expect(eventCount).toBe(2)
    })
  })

  describe('::addItem(item, index)', () => {
    it('adds the item at the given index', () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B')] })
      )
      const [item1, item2] = pane.getItems()
      const item3 = new Item('C')
      pane.addItem(item3, { index: 1 })
      expect(pane.getItems()).toEqual([item1, item3, item2])
    })

    it('adds the item after the active item if no index is provided', () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
      )
      const [item1, item2, item3] = pane.getItems()
      pane.activateItem(item2)
      const item4 = new Item('D')
      pane.addItem(item4)
      expect(pane.getItems()).toEqual([item1, item2, item4, item3])
    })

    it('sets the active item after adding the first item', () => {
      const pane = new Pane(paneParams())
      const item = new Item('A')
      pane.addItem(item)
      expect(pane.getActiveItem()).toBe(item)
    })

    it('invokes ::onDidAddItem() observers', () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B')] })
      )
      const events = []
      pane.onDidAddItem(event => events.push(event))

      const item = new Item('C')
      pane.addItem(item, { index: 1 })
      expect(events).toEqual([{ item, index: 1, moved: false }])
    })

    it('throws an exception if the item is already present on a pane', () => {
      const item = new Item('A')
      const container = new PaneContainer({
        config: atom.config,
        applicationDelegate: atom.applicationDelegate
      })
      const pane1 = container.getActivePane()
      pane1.addItem(item)
      const pane2 = pane1.splitRight()
      expect(() => pane2.addItem(item)).toThrow()
    })

    it("throws an exception if the item isn't an object", () => {
      const pane = new Pane(paneParams({ items: [] }))
      expect(() => pane.addItem(null)).toThrow()
      expect(() => pane.addItem('foo')).toThrow()
      expect(() => pane.addItem(1)).toThrow()
    })

    it('destroys any existing pending item', () => {
      const pane = new Pane(paneParams({ items: [] }))
      const itemA = new Item('A')
      const itemB = new Item('B')
      const itemC = new Item('C')
      pane.addItem(itemA, { pending: false })
      pane.addItem(itemB, { pending: true })
      pane.addItem(itemC, { pending: false })
      expect(itemB.isDestroyed()).toBe(true)
    })

    it('adds the new item before destroying any existing pending item', () => {
      const eventOrder = []

      const pane = new Pane(paneParams({ items: [] }))
      const itemA = new Item('A')
      const itemB = new Item('B')
      pane.addItem(itemA, { pending: true })

      pane.onDidAddItem(function ({ item }) {
        if (item === itemB) eventOrder.push('add')
      })

      pane.onDidRemoveItem(function ({ item }) {
        if (item === itemA) eventOrder.push('remove')
      })

      pane.addItem(itemB)

      waitsFor(() => eventOrder.length === 2)

      runs(() => expect(eventOrder).toEqual(['add', 'remove']))
    })

    it('subscribes to be notified when item terminates its pending state', () => {
      const fakeDisposable = { dispose: () => {} }
      const spy = jasmine
        .createSpy('onDidTerminatePendingState')
        .andReturn(fakeDisposable)

      const pane = new Pane(paneParams({ items: [] }))
      const item = {
        getTitle: () => '',
        onDidTerminatePendingState: spy
      }
      pane.addItem(item)

      expect(spy).toHaveBeenCalled()
    })

    it('subscribes to be notified when item is destroyed', () => {
      const fakeDisposable = { dispose: () => {} }
      const spy = jasmine.createSpy('onDidDestroy').andReturn(fakeDisposable)

      const pane = new Pane(paneParams({ items: [] }))
      const item = {
        getTitle: () => '',
        onDidDestroy: spy
      }
      pane.addItem(item)

      expect(spy).toHaveBeenCalled()
    })

    describe('when using the old API of ::addItem(item, index)', () => {
      beforeEach(() => spyOn(Grim, 'deprecate'))

      it('supports the older public API', () => {
        const pane = new Pane(paneParams({ items: [] }))
        const itemA = new Item('A')
        const itemB = new Item('B')
        const itemC = new Item('C')
        pane.addItem(itemA, 0)
        pane.addItem(itemB, 0)
        pane.addItem(itemC, 0)
        expect(pane.getItems()).toEqual([itemC, itemB, itemA])
      })

      it('shows a deprecation warning', () => {
        const pane = new Pane(paneParams({ items: [] }))
        pane.addItem(new Item(), 2)
        expect(Grim.deprecate).toHaveBeenCalledWith(
          'Pane::addItem(item, 2) is deprecated in favor of Pane::addItem(item, {index: 2})'
        )
      })
    })
  })

  describe('::activateItem(item)', () => {
    let pane = null

    beforeEach(() => {
      pane = new Pane(paneParams({ items: [new Item('A'), new Item('B')] }))
    })

    it('changes the active item to the current item', () => {
      expect(pane.getActiveItem()).toBe(pane.itemAtIndex(0))
      pane.activateItem(pane.itemAtIndex(1))
      expect(pane.getActiveItem()).toBe(pane.itemAtIndex(1))
    })

    it("adds the given item if it isn't present in ::items", () => {
      const item = new Item('C')
      pane.activateItem(item)
      expect(pane.getItems().includes(item)).toBe(true)
      expect(pane.getActiveItem()).toBe(item)
    })

    it('invokes ::onDidChangeActiveItem() observers', () => {
      const observed = []
      pane.onDidChangeActiveItem(item => observed.push(item))
      pane.activateItem(pane.itemAtIndex(1))
      expect(observed).toEqual([pane.itemAtIndex(1)])
    })

    describe('when the item being activated is pending', () => {
      let itemC = null
      let itemD = null

      beforeEach(() => {
        itemC = new Item('C')
        itemD = new Item('D')
      })

      it('replaces the active item if it is pending', () => {
        pane.activateItem(itemC, { pending: true })
        expect(pane.getItems().map(item => item.name)).toEqual(['A', 'C', 'B'])
        pane.activateItem(itemD, { pending: true })
        expect(pane.getItems().map(item => item.name)).toEqual(['A', 'D', 'B'])
      })

      it('adds the item after the active item if it is not pending', () => {
        pane.activateItem(itemC, { pending: true })
        pane.activateItemAtIndex(2)
        pane.activateItem(itemD, { pending: true })
        expect(pane.getItems().map(item => item.name)).toEqual(['A', 'B', 'D'])
      })
    })
  })

  describe('::setPendingItem', () => {
    let pane = null

    beforeEach(() => {
      pane = atom.workspace.getActivePane()
    })

    it('changes the pending item', () => {
      expect(pane.getPendingItem()).toBeNull()
      pane.setPendingItem('fake item')
      expect(pane.getPendingItem()).toEqual('fake item')
    })
  })

  describe('::onItemDidTerminatePendingState callback', () => {
    let pane = null
    let callbackCalled = false

    beforeEach(() => {
      pane = atom.workspace.getActivePane()
      callbackCalled = false
    })

    it('is called when the pending item changes', () => {
      pane.setPendingItem('fake item one')
      pane.onItemDidTerminatePendingState(function (item) {
        callbackCalled = true
        expect(item).toEqual('fake item one')
      })
      pane.setPendingItem('fake item two')
      expect(callbackCalled).toBeTruthy()
    })

    it('has access to the new pending item via ::getPendingItem', () => {
      pane.setPendingItem('fake item one')
      pane.onItemDidTerminatePendingState(function (item) {
        callbackCalled = true
        expect(pane.getPendingItem()).toEqual('fake item two')
      })
      pane.setPendingItem('fake item two')
      expect(callbackCalled).toBeTruthy()
    })

    it("isn't called when a pending item is replaced with a new one", async () => {
      pane = null
      const pendingSpy = jasmine.createSpy('onItemDidTerminatePendingState')
      const destroySpy = jasmine.createSpy('onWillDestroyItem')

      await atom.workspace.open('sample.txt', { pending: true }).then(() => {
        pane = atom.workspace.getActivePane()
      })

      pane.onItemDidTerminatePendingState(pendingSpy)
      pane.onWillDestroyItem(destroySpy)

      await atom.workspace.open('sample.js', { pending: true })

      expect(destroySpy).toHaveBeenCalled()
      expect(pendingSpy).not.toHaveBeenCalled()
    })
  })

  describe('::activateNextRecentlyUsedItem() and ::activatePreviousRecentlyUsedItem()', () => {
    it('sets the active item to the next/previous item in the itemStack, looping around at either end', () => {
      const pane = new Pane(
        paneParams({
          items: [
            new Item('A'),
            new Item('B'),
            new Item('C'),
            new Item('D'),
            new Item('E')
          ]
        })
      )
      const [item1, item2, item3, item4, item5] = pane.getItems()
      pane.itemStack = [item3, item1, item2, item5, item4]

      pane.activateItem(item4)
      expect(pane.getActiveItem()).toBe(item4)
      pane.activateNextRecentlyUsedItem()
      expect(pane.getActiveItem()).toBe(item5)
      pane.activateNextRecentlyUsedItem()
      expect(pane.getActiveItem()).toBe(item2)
      pane.activatePreviousRecentlyUsedItem()
      expect(pane.getActiveItem()).toBe(item5)
      pane.activatePreviousRecentlyUsedItem()
      expect(pane.getActiveItem()).toBe(item4)
      pane.activatePreviousRecentlyUsedItem()
      expect(pane.getActiveItem()).toBe(item3)
      pane.activatePreviousRecentlyUsedItem()
      expect(pane.getActiveItem()).toBe(item1)
      pane.activateNextRecentlyUsedItem()
      expect(pane.getActiveItem()).toBe(item3)
      pane.activateNextRecentlyUsedItem()
      expect(pane.getActiveItem()).toBe(item4)
      pane.activateNextRecentlyUsedItem()
      pane.moveActiveItemToTopOfStack()
      expect(pane.getActiveItem()).toBe(item5)
      expect(pane.itemStack[4]).toBe(item5)
    })
  })

  describe('::activateNextItem() and ::activatePreviousItem()', () => {
    it('sets the active item to the next/previous item, looping around at either end', () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
      )
      const [item1, item2, item3] = pane.getItems()

      expect(pane.getActiveItem()).toBe(item1)
      pane.activatePreviousItem()
      expect(pane.getActiveItem()).toBe(item3)
      pane.activatePreviousItem()
      expect(pane.getActiveItem()).toBe(item2)
      pane.activateNextItem()
      expect(pane.getActiveItem()).toBe(item3)
      pane.activateNextItem()
      expect(pane.getActiveItem()).toBe(item1)
    })
  })

  describe('::activateLastItem()', () => {
    it('sets the active item to the last item', () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
      )
      const [item1, , item3] = pane.getItems()

      expect(pane.getActiveItem()).toBe(item1)
      pane.activateLastItem()
      expect(pane.getActiveItem()).toBe(item3)
    })
  })

  describe('::moveItemRight() and ::moveItemLeft()', () => {
    it('moves the active item to the right and left, without looping around at either end', () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
      )
      const [item1, item2, item3] = pane.getItems()

      pane.activateItemAtIndex(0)
      expect(pane.getActiveItem()).toBe(item1)
      pane.moveItemLeft()
      expect(pane.getItems()).toEqual([item1, item2, item3])
      pane.moveItemRight()
      expect(pane.getItems()).toEqual([item2, item1, item3])
      pane.moveItemLeft()
      expect(pane.getItems()).toEqual([item1, item2, item3])
      pane.activateItemAtIndex(2)
      expect(pane.getActiveItem()).toBe(item3)
      pane.moveItemRight()
      expect(pane.getItems()).toEqual([item1, item2, item3])
    })
  })

  describe('::activateItemAtIndex(index)', () => {
    it('activates the item at the given index', () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
      )
      const [item1, item2, item3] = pane.getItems()
      pane.activateItemAtIndex(2)
      expect(pane.getActiveItem()).toBe(item3)
      pane.activateItemAtIndex(1)
      expect(pane.getActiveItem()).toBe(item2)
      pane.activateItemAtIndex(0)
      expect(pane.getActiveItem()).toBe(item1)

      // Doesn't fail with out-of-bounds indices
      pane.activateItemAtIndex(100)
      expect(pane.getActiveItem()).toBe(item1)
      pane.activateItemAtIndex(-1)
      expect(pane.getActiveItem()).toBe(item1)
    })
  })

  describe('::destroyItem(item)', () => {
    let pane, item1, item2, item3

    beforeEach(() => {
      pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
      )
      ;[item1, item2, item3] = pane.getItems()
    })

    it('removes the item from the items list and destroys it', () => {
      expect(pane.getActiveItem()).toBe(item1)
      pane.destroyItem(item2)
      expect(pane.getItems().includes(item2)).toBe(false)
      expect(item2.isDestroyed()).toBe(true)
      expect(pane.getActiveItem()).toBe(item1)

      pane.destroyItem(item1)
      expect(pane.getItems().includes(item1)).toBe(false)
      expect(item1.isDestroyed()).toBe(true)
    })

    it('removes the item from the itemStack', () => {
      pane.itemStack = [item2, item3, item1]

      pane.activateItem(item1)
      expect(pane.getActiveItem()).toBe(item1)
      pane.destroyItem(item3)
      expect(pane.itemStack).toEqual([item2, item1])
      expect(pane.getActiveItem()).toBe(item1)

      pane.destroyItem(item1)
      expect(pane.itemStack).toEqual([item2])
      expect(pane.getActiveItem()).toBe(item2)

      pane.destroyItem(item2)
      expect(pane.itemStack).toEqual([])
      expect(pane.getActiveItem()).toBeUndefined()
    })

    it('invokes ::onWillDestroyItem() and PaneContainer::onWillDestroyPaneItem observers before destroying the item', async () => {
      jasmine.useRealClock()
      pane.container = new PaneContainer({ config: atom.config, confirm })
      const events = []

      pane.onWillDestroyItem(async event => {
        expect(item2.isDestroyed()).toBe(false)
        await timeoutPromise(50)
        expect(item2.isDestroyed()).toBe(false)
        events.push(['will-destroy-item', event])
      })

      pane.container.onWillDestroyPaneItem(async event => {
        expect(item2.isDestroyed()).toBe(false)
        await timeoutPromise(50)
        expect(item2.isDestroyed()).toBe(false)
        events.push(['will-destroy-pane-item', event])
      })

      await pane.destroyItem(item2)
      expect(item2.isDestroyed()).toBe(true)
      expect(events).toEqual([
        ['will-destroy-item', { item: item2, index: 1 }],
        ['will-destroy-pane-item', { item: item2, index: 1, pane }]
      ])
    })

    it('invokes ::onWillRemoveItem() observers', () => {
      const events = []
      pane.onWillRemoveItem(event => events.push(event))
      pane.destroyItem(item2)
      expect(events).toEqual([
        { item: item2, index: 1, moved: false, destroyed: true }
      ])
    })

    it('invokes ::onDidRemoveItem() observers', () => {
      const events = []
      pane.onDidRemoveItem(event => events.push(event))
      pane.destroyItem(item2)
      expect(events).toEqual([
        { item: item2, index: 1, moved: false, destroyed: true }
      ])
    })

    describe('when the destroyed item is the active item and is the first item', () => {
      it('activates the next item', () => {
        expect(pane.getActiveItem()).toBe(item1)
        pane.destroyItem(item1)
        expect(pane.getActiveItem()).toBe(item2)
      })
    })

    describe('when the destroyed item is the active item and is not the first item', () => {
      beforeEach(() => pane.activateItem(item2))

      it('activates the previous item', () => {
        expect(pane.getActiveItem()).toBe(item2)
        pane.destroyItem(item2)
        expect(pane.getActiveItem()).toBe(item1)
      })
    })

    describe('if the item is modified', () => {
      let itemURI = null

      beforeEach(() => {
        item1.shouldPromptToSave = () => true
        item1.save = jasmine.createSpy('save')
        item1.saveAs = jasmine.createSpy('saveAs')
        item1.getURI = () => itemURI
      })

      describe('if the [Save] option is selected', () => {
        describe('when the item has a uri', () => {
          it('saves the item before destroying it', async () => {
            itemURI = 'test'
            confirm.andCallFake((options, callback) => callback(0))

            const success = await pane.destroyItem(item1)
            expect(item1.save).toHaveBeenCalled()
            expect(pane.getItems().includes(item1)).toBe(false)
            expect(item1.isDestroyed()).toBe(true)
            expect(success).toBe(true)
          })
        })

        describe('when the item has no uri', () => {
          it('presents a save-as dialog, then saves the item with the given uri before removing and destroying it', async () => {
            jasmine.useRealClock()

            itemURI = null

            showSaveDialog.andCallFake((options, callback) =>
              callback('/selected/path')
            )
            confirm.andCallFake((options, callback) => callback(0))

            const success = await pane.destroyItem(item1)
            expect(showSaveDialog.mostRecentCall.args[0]).toEqual({})

            await conditionPromise(() => item1.saveAs.callCount === 1)
            expect(item1.saveAs).toHaveBeenCalledWith('/selected/path')
            expect(pane.getItems().includes(item1)).toBe(false)
            expect(item1.isDestroyed()).toBe(true)
            expect(success).toBe(true)
          })
        })
      })

      describe("if the [Don't Save] option is selected", () => {
        it('removes and destroys the item without saving it', async () => {
          confirm.andCallFake((options, callback) => callback(2))

          const success = await pane.destroyItem(item1)
          expect(item1.save).not.toHaveBeenCalled()
          expect(pane.getItems().includes(item1)).toBe(false)
          expect(item1.isDestroyed()).toBe(true)
          expect(success).toBe(true)
        })
      })

      describe('if the [Cancel] option is selected', () => {
        it('does not save, remove, or destroy the item', async () => {
          confirm.andCallFake((options, callback) => callback(1))

          const success = await pane.destroyItem(item1)
          expect(item1.save).not.toHaveBeenCalled()
          expect(pane.getItems().includes(item1)).toBe(true)
          expect(item1.isDestroyed()).toBe(false)
          expect(success).toBe(false)
        })
      })

      describe('when force=true', () => {
        it('destroys the item immediately', async () => {
          const success = await pane.destroyItem(item1, true)
          expect(item1.save).not.toHaveBeenCalled()
          expect(pane.getItems().includes(item1)).toBe(false)
          expect(item1.isDestroyed()).toBe(true)
          expect(success).toBe(true)
        })
      })
    })

    describe('when the last item is destroyed', () => {
      describe("when the 'core.destroyEmptyPanes' config option is false (the default)", () => {
        it('does not destroy the pane, but leaves it in place with empty items', () => {
          expect(atom.config.get('core.destroyEmptyPanes')).toBe(false)
          for (let item of pane.getItems()) {
            pane.destroyItem(item)
          }
          expect(pane.isDestroyed()).toBe(false)
          expect(pane.getActiveItem()).toBeUndefined()
          expect(() => pane.saveActiveItem()).not.toThrow()
          expect(() => pane.saveActiveItemAs()).not.toThrow()
        })
      })

      describe("when the 'core.destroyEmptyPanes' config option is true", () => {
        it('destroys the pane', () => {
          atom.config.set('core.destroyEmptyPanes', true)
          for (let item of pane.getItems()) {
            pane.destroyItem(item)
          }
          expect(pane.isDestroyed()).toBe(true)
        })
      })
    })

    describe('when passed a permanent dock item', () => {
      it("doesn't destroy the item", async () => {
        spyOn(item1, 'isPermanentDockItem').andReturn(true)
        const success = await pane.destroyItem(item1)
        expect(pane.getItems().includes(item1)).toBe(true)
        expect(item1.isDestroyed()).toBe(false)
        expect(success).toBe(false)
      })

      it('destroy the item if force=true', async () => {
        spyOn(item1, 'isPermanentDockItem').andReturn(true)
        const success = await pane.destroyItem(item1, true)
        expect(pane.getItems().includes(item1)).toBe(false)
        expect(item1.isDestroyed()).toBe(true)
        expect(success).toBe(true)
      })
    })
  })

  describe('::destroyActiveItem()', () => {
    it('destroys the active item', () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B')] })
      )
      const activeItem = pane.getActiveItem()
      pane.destroyActiveItem()
      expect(activeItem.isDestroyed()).toBe(true)
      expect(pane.getItems().includes(activeItem)).toBe(false)
    })

    it('does not throw an exception if there are no more items', () => {
      const pane = new Pane(paneParams())
      pane.destroyActiveItem()
    })
  })

  describe('::destroyItems()', () => {
    it('destroys all items', async () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
      )
      const [item1, item2, item3] = pane.getItems()

      await pane.destroyItems()
      expect(item1.isDestroyed()).toBe(true)
      expect(item2.isDestroyed()).toBe(true)
      expect(item3.isDestroyed()).toBe(true)
      expect(pane.getItems()).toEqual([])
    })
  })

  describe('::observeItems()', () => {
    it('invokes the observer with all current and future items', () => {
      const pane = new Pane(paneParams({ items: [new Item(), new Item()] }))
      const [item1, item2] = pane.getItems()

      const observed = []
      pane.observeItems(item => observed.push(item))

      const item3 = new Item()
      pane.addItem(item3)

      expect(observed).toEqual([item1, item2, item3])
    })
  })

  describe('when an item emits a destroyed event', () => {
    it('removes it from the list of items', () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
      )
      const [item1, , item3] = pane.getItems()
      pane.itemAtIndex(1).destroy()
      expect(pane.getItems()).toEqual([item1, item3])
    })
  })

  describe('::destroyInactiveItems()', () => {
    it('destroys all items but the active item', () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B'), new Item('C')] })
      )
      const [, item2] = pane.getItems()
      pane.activateItem(item2)
      pane.destroyInactiveItems()
      expect(pane.getItems()).toEqual([item2])
    })
  })

  describe('::saveActiveItem()', () => {
    let pane

    beforeEach(() => {
      pane = new Pane(paneParams({ items: [new Item('A')] }))
      showSaveDialog.andCallFake((options, callback) =>
        callback('/selected/path')
      )
    })

    describe('when the active item has a uri', () => {
      beforeEach(() => {
        pane.getActiveItem().uri = 'test'
      })

      describe('when the active item has a save method', () => {
        it('saves the current item', () => {
          pane.getActiveItem().save = jasmine.createSpy('save')
          pane.saveActiveItem()
          expect(pane.getActiveItem().save).toHaveBeenCalled()
        })
      })

      describe('when the current item has no save method', () => {
        it('does nothing', () => {
          expect(pane.getActiveItem().save).toBeUndefined()
          pane.saveActiveItem()
        })
      })
    })

    describe('when the current item has no uri', () => {
      describe('when the current item has a saveAs method', () => {
        it('opens a save dialog and saves the current item as the selected path', async () => {
          pane.getActiveItem().saveAs = jasmine.createSpy('saveAs')
          await pane.saveActiveItem()
          expect(showSaveDialog.mostRecentCall.args[0]).toEqual({})
          expect(pane.getActiveItem().saveAs).toHaveBeenCalledWith(
            '/selected/path'
          )
        })
      })

      describe('when the current item has no saveAs method', () => {
        it('does nothing', async () => {
          expect(pane.getActiveItem().saveAs).toBeUndefined()
          await pane.saveActiveItem()
          expect(showSaveDialog).not.toHaveBeenCalled()
        })
      })

      it('does nothing if the user cancels choosing a path', async () => {
        pane.getActiveItem().saveAs = jasmine.createSpy('saveAs')
        showSaveDialog.andCallFake((options, callback) => callback(undefined))
        await pane.saveActiveItem()
        expect(pane.getActiveItem().saveAs).not.toHaveBeenCalled()
      })
    })

    describe("when the item's saveAs rejects with a well-known IO error", () => {
      it('creates a notification', () => {
        pane.getActiveItem().saveAs = () => {
          const error = new Error("EACCES, permission denied '/foo'")
          error.path = '/foo'
          error.code = 'EACCES'
          return Promise.reject(error)
        }

        waitsFor(done => {
          const subscription = atom.notifications.onDidAddNotification(
            function (notification) {
              expect(notification.getType()).toBe('warning')
              expect(notification.getMessage()).toContain('Permission denied')
              expect(notification.getMessage()).toContain('/foo')
              subscription.dispose()
              done()
            }
          )
          pane.saveActiveItem()
        })
      })
    })

    describe("when the item's saveAs throws a well-known IO error", () => {
      it('creates a notification', () => {
        pane.getActiveItem().saveAs = () => {
          const error = new Error("EACCES, permission denied '/foo'")
          error.path = '/foo'
          error.code = 'EACCES'
          throw error
        }

        waitsFor(done => {
          const subscription = atom.notifications.onDidAddNotification(
            function (notification) {
              expect(notification.getType()).toBe('warning')
              expect(notification.getMessage()).toContain('Permission denied')
              expect(notification.getMessage()).toContain('/foo')
              subscription.dispose()
              done()
            }
          )
          pane.saveActiveItem()
        })
      })
    })
  })

  describe('::saveActiveItemAs()', () => {
    let pane = null

    beforeEach(() => {
      pane = new Pane(paneParams({ items: [new Item('A')] }))
      showSaveDialog.andCallFake((options, callback) =>
        callback('/selected/path')
      )
    })

    describe('when the current item has a saveAs method', () => {
      it('opens the save dialog and calls saveAs on the item with the selected path', async () => {
        jasmine.useRealClock()

        pane.getActiveItem().path = __filename
        pane.getActiveItem().saveAs = jasmine.createSpy('saveAs')
        pane.saveActiveItemAs()
        expect(showSaveDialog.mostRecentCall.args[0]).toEqual({
          defaultPath: __filename
        })

        await conditionPromise(
          () => pane.getActiveItem().saveAs.callCount === 1
        )
        expect(pane.getActiveItem().saveAs).toHaveBeenCalledWith(
          '/selected/path'
        )
      })
    })

    describe('when the current item does not have a saveAs method', () => {
      it('does nothing', () => {
        expect(pane.getActiveItem().saveAs).toBeUndefined()
        pane.saveActiveItemAs()
        expect(showSaveDialog).not.toHaveBeenCalled()
      })
    })

    describe("when the item's saveAs method throws a well-known IO error", () => {
      it('creates a notification', () => {
        pane.getActiveItem().saveAs = () => {
          const error = new Error("EACCES, permission denied '/foo'")
          error.path = '/foo'
          error.code = 'EACCES'
          return Promise.reject(error)
        }

        waitsFor(done => {
          const subscription = atom.notifications.onDidAddNotification(
            function (notification) {
              expect(notification.getType()).toBe('warning')
              expect(notification.getMessage()).toContain('Permission denied')
              expect(notification.getMessage()).toContain('/foo')
              subscription.dispose()
              done()
            }
          )
          pane.saveActiveItemAs()
        })
      })
    })
  })

  describe('::itemForURI(uri)', () => {
    it('returns the item for which a call to .getURI() returns the given uri', () => {
      const pane = new Pane(
        paneParams({
          items: [new Item('A'), new Item('B'), new Item('C'), new Item('D')]
        })
      )
      const [item1, item2] = pane.getItems()
      item1.uri = 'a'
      item2.uri = 'b'
      expect(pane.itemForURI('a')).toBe(item1)
      expect(pane.itemForURI('b')).toBe(item2)
      expect(pane.itemForURI('bogus')).toBeUndefined()
    })
  })

  describe('::moveItem(item, index)', () => {
    let pane, item1, item2, item3, item4

    beforeEach(() => {
      pane = new Pane(
        paneParams({
          items: [new Item('A'), new Item('B'), new Item('C'), new Item('D')]
        })
      )
      ;[item1, item2, item3, item4] = pane.getItems()
    })

    it('moves the item to the given index and invokes ::onDidMoveItem observers', () => {
      pane.moveItem(item1, 2)
      expect(pane.getItems()).toEqual([item2, item3, item1, item4])

      pane.moveItem(item2, 3)
      expect(pane.getItems()).toEqual([item3, item1, item4, item2])

      pane.moveItem(item2, 1)
      expect(pane.getItems()).toEqual([item3, item2, item1, item4])
    })

    it('invokes ::onDidMoveItem() observers', () => {
      const events = []
      pane.onDidMoveItem(event => events.push(event))

      pane.moveItem(item1, 2)
      pane.moveItem(item2, 3)
      expect(events).toEqual([
        { item: item1, oldIndex: 0, newIndex: 2 },
        { item: item2, oldIndex: 0, newIndex: 3 }
      ])
    })
  })

  describe('::moveItemToPane(item, pane, index)', () => {
    let container, pane1, pane2
    let item1, item2, item3, item4, item5

    beforeEach(() => {
      container = new PaneContainer({ config: atom.config, confirm })
      pane1 = container.getActivePane()
      pane1.addItems([new Item('A'), new Item('B'), new Item('C')])
      pane2 = pane1.splitRight({ items: [new Item('D'), new Item('E')] })
      ;[item1, item2, item3] = pane1.getItems()
      ;[item4, item5] = pane2.getItems()
    })

    it('moves the item to the given pane at the given index', () => {
      pane1.moveItemToPane(item2, pane2, 1)
      expect(pane1.getItems()).toEqual([item1, item3])
      expect(pane2.getItems()).toEqual([item4, item2, item5])
    })

    it('invokes ::onWillRemoveItem() observers', () => {
      const events = []
      pane1.onWillRemoveItem(event => events.push(event))
      pane1.moveItemToPane(item2, pane2, 1)

      expect(events).toEqual([
        { item: item2, index: 1, moved: true, destroyed: false }
      ])
    })

    it('invokes ::onDidRemoveItem() observers', () => {
      const events = []
      pane1.onDidRemoveItem(event => events.push(event))
      pane1.moveItemToPane(item2, pane2, 1)

      expect(events).toEqual([
        { item: item2, index: 1, moved: true, destroyed: false }
      ])
    })

    it('does not invoke ::onDidAddPaneItem observers on the container', () => {
      const addedItems = []
      container.onDidAddPaneItem(item => addedItems.push(item))
      pane1.moveItemToPane(item2, pane2, 1)
      expect(addedItems).toEqual([])
    })

    describe('when the moved item the last item in the source pane', () => {
      beforeEach(() => item5.destroy())

      describe("when the 'core.destroyEmptyPanes' config option is false (the default)", () => {
        it('does not destroy the pane or the item', () => {
          pane2.moveItemToPane(item4, pane1, 0)
          expect(pane2.isDestroyed()).toBe(false)
          expect(item4.isDestroyed()).toBe(false)
        })
      })

      describe("when the 'core.destroyEmptyPanes' config option is true", () => {
        it('destroys the pane, but not the item', () => {
          atom.config.set('core.destroyEmptyPanes', true)
          pane2.moveItemToPane(item4, pane1, 0)
          expect(pane2.isDestroyed()).toBe(true)
          expect(item4.isDestroyed()).toBe(false)
        })
      })
    })

    describe('when the item being moved is pending', () => {
      it('is made permanent in the new pane', () => {
        const item6 = new Item('F')
        pane1.addItem(item6, { pending: true })
        expect(pane1.getPendingItem()).toEqual(item6)
        pane1.moveItemToPane(item6, pane2, 0)
        expect(pane2.getPendingItem()).not.toEqual(item6)
      })
    })

    describe('when the target pane has a pending item', () => {
      it('does not destroy the pending item', () => {
        const item6 = new Item('F')
        pane1.addItem(item6, { pending: true })
        expect(pane1.getPendingItem()).toEqual(item6)
        pane2.moveItemToPane(item5, pane1, 0)
        expect(pane1.getPendingItem()).toEqual(item6)
      })
    })
  })

  describe('split methods', () => {
    let pane1, item1, container

    beforeEach(() => {
      container = new PaneContainer({
        config: atom.config,
        confirm,
        deserializerManager: atom.deserializers
      })
      pane1 = container.getActivePane()
      item1 = new Item('A')
      pane1.addItem(item1)
    })

    describe('::splitLeft(params)', () => {
      describe('when the parent is the container root', () => {
        it('replaces itself with a row and inserts a new pane to the left of itself', () => {
          const pane2 = pane1.splitLeft({ items: [new Item('B')] })
          const pane3 = pane1.splitLeft({ items: [new Item('C')] })
          expect(container.root.orientation).toBe('horizontal')
          expect(container.root.children).toEqual([pane2, pane3, pane1])
        })
      })

      describe('when `moveActiveItem: true` is passed in the params', () => {
        it('moves the active item', () => {
          const pane2 = pane1.splitLeft({ moveActiveItem: true })
          expect(pane2.getActiveItem()).toBe(item1)
        })
      })

      describe('when `copyActiveItem: true` is passed in the params', () => {
        it('duplicates the active item', () => {
          const pane2 = pane1.splitLeft({ copyActiveItem: true })
          expect(pane2.getActiveItem()).toEqual(pane1.getActiveItem())
        })

        it("does nothing if the active item doesn't implement .copy()", () => {
          item1.copy = null
          const pane2 = pane1.splitLeft({ copyActiveItem: true })
          expect(pane2.getActiveItem()).toBeUndefined()
        })
      })

      describe('when the parent is a column', () => {
        it('replaces itself with a row and inserts a new pane to the left of itself', () => {
          pane1.splitDown()
          const pane2 = pane1.splitLeft({ items: [new Item('B')] })
          const pane3 = pane1.splitLeft({ items: [new Item('C')] })
          const row = container.root.children[0]
          expect(row.orientation).toBe('horizontal')
          expect(row.children).toEqual([pane2, pane3, pane1])
        })
      })
    })

    describe('::splitRight(params)', () => {
      describe('when the parent is the container root', () => {
        it('replaces itself with a row and inserts a new pane to the right of itself', () => {
          const pane2 = pane1.splitRight({ items: [new Item('B')] })
          const pane3 = pane1.splitRight({ items: [new Item('C')] })
          expect(container.root.orientation).toBe('horizontal')
          expect(container.root.children).toEqual([pane1, pane3, pane2])
        })
      })

      describe('when `moveActiveItem: true` is passed in the params', () => {
        it('moves the active item', () => {
          const pane2 = pane1.splitRight({ moveActiveItem: true })
          expect(pane2.getActiveItem()).toBe(item1)
        })
      })

      describe('when `copyActiveItem: true` is passed in the params', () => {
        it('duplicates the active item', () => {
          const pane2 = pane1.splitRight({ copyActiveItem: true })
          expect(pane2.getActiveItem()).toEqual(pane1.getActiveItem())
        })
      })

      describe('when the parent is a column', () => {
        it('replaces itself with a row and inserts a new pane to the right of itself', () => {
          pane1.splitDown()
          const pane2 = pane1.splitRight({ items: [new Item('B')] })
          const pane3 = pane1.splitRight({ items: [new Item('C')] })
          const row = container.root.children[0]
          expect(row.orientation).toBe('horizontal')
          expect(row.children).toEqual([pane1, pane3, pane2])
        })
      })
    })

    describe('::splitUp(params)', () => {
      describe('when the parent is the container root', () => {
        it('replaces itself with a column and inserts a new pane above itself', () => {
          const pane2 = pane1.splitUp({ items: [new Item('B')] })
          const pane3 = pane1.splitUp({ items: [new Item('C')] })
          expect(container.root.orientation).toBe('vertical')
          expect(container.root.children).toEqual([pane2, pane3, pane1])
        })
      })

      describe('when `moveActiveItem: true` is passed in the params', () => {
        it('moves the active item', () => {
          const pane2 = pane1.splitUp({ moveActiveItem: true })
          expect(pane2.getActiveItem()).toBe(item1)
        })
      })

      describe('when `copyActiveItem: true` is passed in the params', () => {
        it('duplicates the active item', () => {
          const pane2 = pane1.splitUp({ copyActiveItem: true })
          expect(pane2.getActiveItem()).toEqual(pane1.getActiveItem())
        })
      })

      describe('when the parent is a row', () => {
        it('replaces itself with a column and inserts a new pane above itself', () => {
          pane1.splitRight()
          const pane2 = pane1.splitUp({ items: [new Item('B')] })
          const pane3 = pane1.splitUp({ items: [new Item('C')] })
          const column = container.root.children[0]
          expect(column.orientation).toBe('vertical')
          expect(column.children).toEqual([pane2, pane3, pane1])
        })
      })
    })

    describe('::splitDown(params)', () => {
      describe('when the parent is the container root', () => {
        it('replaces itself with a column and inserts a new pane below itself', () => {
          const pane2 = pane1.splitDown({ items: [new Item('B')] })
          const pane3 = pane1.splitDown({ items: [new Item('C')] })
          expect(container.root.orientation).toBe('vertical')
          expect(container.root.children).toEqual([pane1, pane3, pane2])
        })
      })

      describe('when `moveActiveItem: true` is passed in the params', () => {
        it('moves the active item', () => {
          const pane2 = pane1.splitDown({ moveActiveItem: true })
          expect(pane2.getActiveItem()).toBe(item1)
        })
      })

      describe('when `copyActiveItem: true` is passed in the params', () => {
        it('duplicates the active item', () => {
          const pane2 = pane1.splitDown({ copyActiveItem: true })
          expect(pane2.getActiveItem()).toEqual(pane1.getActiveItem())
        })
      })

      describe('when the parent is a row', () => {
        it('replaces itself with a column and inserts a new pane below itself', () => {
          pane1.splitRight()
          const pane2 = pane1.splitDown({ items: [new Item('B')] })
          const pane3 = pane1.splitDown({ items: [new Item('C')] })
          const column = container.root.children[0]
          expect(column.orientation).toBe('vertical')
          expect(column.children).toEqual([pane1, pane3, pane2])
        })
      })
    })

    describe('when the pane is empty', () => {
      describe('when `moveActiveItem: true` is passed in the params', () => {
        it('gracefully ignores the moveActiveItem parameter', () => {
          pane1.destroyItem(item1)
          expect(pane1.getActiveItem()).toBe(undefined)

          const pane2 = pane1.split('horizontal', 'before', {
            moveActiveItem: true
          })
          expect(container.root.children).toEqual([pane2, pane1])

          expect(pane2.getActiveItem()).toBe(undefined)
        })
      })

      describe('when `copyActiveItem: true` is passed in the params', () => {
        it('gracefully ignores the copyActiveItem parameter', () => {
          pane1.destroyItem(item1)
          expect(pane1.getActiveItem()).toBe(undefined)

          const pane2 = pane1.split('horizontal', 'before', {
            copyActiveItem: true
          })
          expect(container.root.children).toEqual([pane2, pane1])

          expect(pane2.getActiveItem()).toBe(undefined)
        })
      })
    })

    it('activates the new pane', () => {
      expect(pane1.isActive()).toBe(true)
      const pane2 = pane1.splitRight()
      expect(pane1.isActive()).toBe(false)
      expect(pane2.isActive()).toBe(true)
    })
  })

  describe('::close()', () => {
    it('prompts to save unsaved items before destroying the pane', async () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B')] })
      )
      const [item1] = pane.getItems()

      item1.shouldPromptToSave = () => true
      item1.getURI = () => '/test/path'
      item1.save = jasmine.createSpy('save')

      confirm.andCallFake((options, callback) => callback(0))
      await pane.close()
      expect(confirm).toHaveBeenCalled()
      expect(item1.save).toHaveBeenCalled()
      expect(pane.isDestroyed()).toBe(true)
    })

    it('does not destroy the pane if the user clicks cancel', async () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B')] })
      )
      const [item1] = pane.getItems()

      item1.shouldPromptToSave = () => true
      item1.getURI = () => '/test/path'
      item1.save = jasmine.createSpy('save')

      confirm.andCallFake((options, callback) => callback(1))

      await pane.close()
      expect(confirm).toHaveBeenCalled()
      expect(item1.save).not.toHaveBeenCalled()
      expect(pane.isDestroyed()).toBe(false)
    })

    it('does not destroy the pane if the user starts to save but then does not choose a path', async () => {
      const pane = new Pane(
        paneParams({ items: [new Item('A'), new Item('B')] })
      )
      const [item1] = pane.getItems()

      item1.shouldPromptToSave = () => true
      item1.saveAs = jasmine.createSpy('saveAs')

      confirm.andCallFake((options, callback) => callback(0))
      showSaveDialog.andCallFake((options, callback) => callback(undefined))

      await pane.close()
      expect(atom.applicationDelegate.confirm).toHaveBeenCalled()
      expect(confirm.callCount).toBe(1)
      expect(item1.saveAs).not.toHaveBeenCalled()
      expect(pane.isDestroyed()).toBe(false)
    })

    describe('when item fails to save', () => {
      let pane, item1

      beforeEach(() => {
        pane = new Pane({
          items: [new Item('A'), new Item('B')],
          applicationDelegate: atom.applicationDelegate,
          config: atom.config
        })
        ;[item1] = pane.getItems()

        item1.shouldPromptToSave = () => true
        item1.getURI = () => '/test/path'

        item1.save = jasmine.createSpy('save').andCallFake(() => {
          const error = new Error("EACCES, permission denied '/test/path'")
          error.path = '/test/path'
          error.code = 'EACCES'
          throw error
        })
      })

      it('does not destroy the pane if save fails and user clicks cancel', async () => {
        let confirmations = 0
        confirm.andCallFake((options, callback) => {
          confirmations++
          if (confirmations === 1) {
            callback(0) // click save
          } else {
            callback(1)
          }
        }) // click cancel

        await pane.close()
        expect(atom.applicationDelegate.confirm).toHaveBeenCalled()
        expect(confirmations).toBe(2)
        expect(item1.save).toHaveBeenCalled()
        expect(pane.isDestroyed()).toBe(false)
      })

      it('does destroy the pane if the user saves the file under a new name', async () => {
        item1.saveAs = jasmine.createSpy('saveAs').andReturn(true)

        let confirmations = 0
        confirm.andCallFake((options, callback) => {
          confirmations++
          callback(0)
        }) // save and then save as

        showSaveDialog.andCallFake((options, callback) => callback('new/path'))

        await pane.close()
        expect(atom.applicationDelegate.confirm).toHaveBeenCalled()
        expect(confirmations).toBe(2)
        expect(
          atom.applicationDelegate.showSaveDialog.mostRecentCall.args[0]
        ).toEqual({})
        expect(item1.save).toHaveBeenCalled()
        expect(item1.saveAs).toHaveBeenCalled()
        expect(pane.isDestroyed()).toBe(true)
      })

      it('asks again if the saveAs also fails', async () => {
        item1.saveAs = jasmine.createSpy('saveAs').andCallFake(() => {
          const error = new Error("EACCES, permission denied '/test/path'")
          error.path = '/test/path'
          error.code = 'EACCES'
          throw error
        })

        let confirmations = 0
        confirm.andCallFake((options, callback) => {
          confirmations++
          if (confirmations < 3) {
            callback(0) // save, save as, save as
          } else {
            callback(2) // don't save
          }
        })

        showSaveDialog.andCallFake((options, callback) => callback('new/path'))

        await pane.close()
        expect(atom.applicationDelegate.confirm).toHaveBeenCalled()
        expect(confirmations).toBe(3)
        expect(
          atom.applicationDelegate.showSaveDialog.mostRecentCall.args[0]
        ).toEqual({})
        expect(item1.save).toHaveBeenCalled()
        expect(item1.saveAs).toHaveBeenCalled()
        expect(pane.isDestroyed()).toBe(true)
      })
    })
  })

  describe('::destroy()', () => {
    let container, pane1, pane2

    beforeEach(() => {
      container = new PaneContainer({ config: atom.config, confirm })
      pane1 = container.root
      pane1.addItems([new Item('A'), new Item('B')])
      pane2 = pane1.splitRight()
    })

    it('invokes ::onWillDestroy observers before destroying items', () => {
      let itemsDestroyed = null
      pane1.onWillDestroy(() => {
        itemsDestroyed = pane1.getItems().map(item => item.isDestroyed())
      })
      pane1.destroy()
      expect(itemsDestroyed).toEqual([false, false])
    })

    it("destroys the pane's destroyable items", () => {
      const [item1, item2] = pane1.getItems()
      pane1.destroy()
      expect(item1.isDestroyed()).toBe(true)
      expect(item2.isDestroyed()).toBe(true)
    })

    describe('if the pane is active', () => {
      it('makes the next pane active', () => {
        expect(pane2.isActive()).toBe(true)
        pane2.destroy()
        expect(pane1.isActive()).toBe(true)
      })
    })

    describe("if the pane's parent has more than two children", () => {
      it('removes the pane from its parent', () => {
        const pane3 = pane2.splitRight()

        expect(container.root.children).toEqual([pane1, pane2, pane3])
        pane2.destroy()
        expect(container.root.children).toEqual([pane1, pane3])
      })
    })

    describe("if the pane's parent has two children", () => {
      it('replaces the parent with its last remaining child', () => {
        const pane3 = pane2.splitDown()

        expect(container.root.children[0]).toBe(pane1)
        expect(container.root.children[1].children).toEqual([pane2, pane3])
        pane3.destroy()
        expect(container.root.children).toEqual([pane1, pane2])
        pane2.destroy()
        expect(container.root).toBe(pane1)
      })
    })
  })

  describe('pending state', () => {
    let editor1, pane, eventCount

    beforeEach(async () => {
      editor1 = await atom.workspace.open('sample.txt', { pending: true })
      pane = atom.workspace.getActivePane()
      eventCount = 0
      editor1.onDidTerminatePendingState(() => eventCount++)
    })

    it('does not open file in pending state by default', async () => {
      await atom.workspace.open('sample.js')
      expect(pane.getPendingItem()).toBeNull()
    })

    it("opens file in pending state if 'pending' option is true", () => {
      expect(pane.getPendingItem()).toEqual(editor1)
    })

    it('terminates pending state if ::terminatePendingState is invoked', () => {
      editor1.terminatePendingState()

      expect(pane.getPendingItem()).toBeNull()
      expect(eventCount).toBe(1)
    })

    it('terminates pending state when buffer is changed', () => {
      editor1.insertText("I'll be back!")
      advanceClock(editor1.getBuffer().stoppedChangingDelay)

      expect(pane.getPendingItem()).toBeNull()
      expect(eventCount).toBe(1)
    })

    it('only calls terminate handler once when text is modified twice', async () => {
      const originalText = editor1.getText()
      editor1.insertText('Some text')
      advanceClock(editor1.getBuffer().stoppedChangingDelay)

      await editor1.save()

      editor1.insertText('More text')
      advanceClock(editor1.getBuffer().stoppedChangingDelay)

      expect(pane.getPendingItem()).toBeNull()
      expect(eventCount).toBe(1)

      // Reset fixture back to original state
      editor1.setText(originalText)
      await editor1.save()
    })

    it('only calls clearPendingItem if there is a pending item to clear', () => {
      spyOn(pane, 'clearPendingItem').andCallThrough()

      editor1.terminatePendingState()
      editor1.terminatePendingState()

      expect(pane.getPendingItem()).toBeNull()
      expect(pane.clearPendingItem.callCount).toBe(1)
    })
  })

  describe('serialization', () => {
    let pane = null

    beforeEach(() => {
      pane = new Pane(
        paneParams({
          items: [new Item('A', 'a'), new Item('B', 'b'), new Item('C', 'c')],
          flexScale: 2
        })
      )
    })

    it('can serialize and deserialize the pane and all its items', () => {
      const newPane = Pane.deserialize(pane.serialize(), atom)
      expect(newPane.getItems()).toEqual(pane.getItems())
    })

    it('restores the active item on deserialization', () => {
      pane.activateItemAtIndex(1)
      const newPane = Pane.deserialize(pane.serialize(), atom)
      expect(newPane.getActiveItem()).toEqual(newPane.itemAtIndex(1))
    })

    it("restores the active item when it doesn't implement getURI()", () => {
      pane.items[1].getURI = null
      pane.activateItemAtIndex(1)
      const newPane = Pane.deserialize(pane.serialize(), atom)
      expect(newPane.getActiveItem()).toEqual(newPane.itemAtIndex(1))
    })

    it("restores the correct item when it doesn't implement getURI() and some items weren't deserialized", () => {
      const unserializable = {}
      pane.addItem(unserializable, { index: 0 })
      pane.items[2].getURI = null
      pane.activateItemAtIndex(2)
      const newPane = Pane.deserialize(pane.serialize(), atom)
      expect(newPane.getActiveItem()).toEqual(newPane.itemAtIndex(1))
    })

    it('does not include items that cannot be deserialized', () => {
      spyOn(console, 'warn')
      const unserializable = {}
      pane.activateItem(unserializable)

      const newPane = Pane.deserialize(pane.serialize(), atom)
      expect(newPane.getActiveItem()).toEqual(pane.itemAtIndex(0))
      expect(newPane.getItems().length).toBe(pane.getItems().length - 1)
    })

    it("includes the pane's focus state in the serialized state", () => {
      pane.focus()
      const newPane = Pane.deserialize(pane.serialize(), atom)
      expect(newPane.focused).toBe(true)
    })

    it('can serialize and deserialize the order of the items in the itemStack', () => {
      const [item1, item2, item3] = pane.getItems()
      pane.itemStack = [item3, item1, item2]
      const newPane = Pane.deserialize(pane.serialize(), atom)
      expect(newPane.itemStack).toEqual(pane.itemStack)
      expect(newPane.itemStack[2]).toEqual(item2)
    })

    it('builds the itemStack if the itemStack is not serialized', () => {
      const newPane = Pane.deserialize(pane.serialize(), atom)
      expect(newPane.getItems()).toEqual(newPane.itemStack)
    })

    it('rebuilds the itemStack if items.length does not match itemStack.length', () => {
      const [, item2, item3] = pane.getItems()
      pane.itemStack = [item2, item3]
      const newPane = Pane.deserialize(pane.serialize(), atom)
      expect(newPane.getItems()).toEqual(newPane.itemStack)
    })

    it('does not serialize the reference to the items in the itemStack for pane items that will not be serialized', () => {
      const [item1, item2, item3] = pane.getItems()
      pane.itemStack = [item2, item1, item3]
      const unserializable = {}
      pane.activateItem(unserializable)

      const newPane = Pane.deserialize(pane.serialize(), atom)
      expect(newPane.itemStack).toEqual([item2, item1, item3])
    })
  })
})