import _shuffle from 'lodash/shuffle'

import {
  allProducedAttributesExpected,
  createWorkflowStoreSnapshot,
  selectAllActionRelationsAsExecutionExpected,
  selectAllProducedAttributesBeforeActionExected,
  selectAllViewsAsOutputExpected,
  selectFirstActionRelationAttributesExpected,
} from './mocks/store.mock'
import {
  selectAction,
  selectActionRelationAttributes,
  selectActionsCost,
  selectActionsTime,
  selectAllActionRelationsAsExecution,
  selectAllActionRelationsProducedAttributes,
  selectAllMissedActionRelations,
  selectAllProducedAttributesBeforeActionRelation,
  selectAllViewsAsOutput,
  selectNormalizedActionRelationsSequence,
} from './selectors'
import { createStore } from './store'

describe('selectors', () => {
  it('should select actions time & cost', () => {
    const store = createStore(createWorkflowStoreSnapshot())
    const state = store.getState()

    const cost = selectActionsCost()(state)
    const time = selectActionsTime()(state)

    expect(cost).toBe(0)
    expect(time).toBe(1)
  })

  it('should select action attributes', () => {
    const store = createStore(createWorkflowStoreSnapshot())
    const state = store.getState()
    const { relations } = state

    const actionAttrs = selectAction(relations[0].id)(state)
    const actionAttrsPipeline = selectActionRelationAttributes(relations[0].id)(
      state
    )
    const allProducedAttrs = selectAllActionRelationsProducedAttributes()(state)
    const beforeAttrs = selectAllProducedAttributesBeforeActionRelation(
      relations[2].id
    )(state)

    const expectedAttrs = selectFirstActionRelationAttributesExpected()

    expect(actionAttrs.lAttributes).toStrictEqual(expectedAttrs.lAttributes)
    expect(actionAttrs.pAttributes).toStrictEqual(expectedAttrs.pAttributes)
    expect(actionAttrs.rAttributes).toStrictEqual(expectedAttrs.rAttributes)

    expect(allProducedAttrs).toStrictEqual(allProducedAttributesExpected())

    expect(beforeAttrs).toStrictEqual(
      selectAllProducedAttributesBeforeActionExected()
    )

    expect(actionAttrsPipeline.rAttributes).toStrictEqual(
      expectedAttrs.rAttributes
    )
  })

  it('should select relations correctly and detect missed', () => {
    const store = createStore(createWorkflowStoreSnapshot())
    const state = store.getState()
    const relations = _shuffle([...state.relations])
    const missedRelations = [
      ...relations,
      {
        ...relations[0],
        id: 'none',
        rel: [],
      },
    ]

    const missedRels = selectAllMissedActionRelations()({
      ...state,
      relations: missedRelations,
    })

    const correctRelations = selectNormalizedActionRelationsSequence()({
      ...state,
      relations: missedRelations,
    })

    const expectedRelations = createWorkflowStoreSnapshot().relations.map(
      ({ rel }) => rel[0]
    )

    expect(missedRels.length).toEqual(1)
    expect(correctRelations.map(({ rel }) => rel[0])).toEqual(expectedRelations)
  })

  it('should select all action relations as execution', () => {
    const store = createStore(createWorkflowStoreSnapshot())
    const state = store.getState()
    const { relations } = state

    const execution = selectAllActionRelationsAsExecution()(state)
    expect(execution.length).toEqual(relations.length)
    expect(execution).toStrictEqual(
      selectAllActionRelationsAsExecutionExpected()
    )
  })

  it('should select views as old output', () => {
    const store = createStore(createWorkflowStoreSnapshot())
    const state = store.getState()

    const output = selectAllViewsAsOutput()(state)
    // console.log(JSON.stringify(state, null, 2))
    // console.log(JSON.stringify(output, null, 2))
    expect(output).toStrictEqual(selectAllViewsAsOutputExpected())
  })
})