import 'jest'
jest.mock('@feedyou/utils/dist/azurestorage')

import {
  getEntityGenerator,
  Query,
  QueryTable,
  TranslateToObject,
  UpsertTable,
  CreateTableIfNotExists,
  DeleteEntity
} from '@feedyou/utils/dist/azurestorage'
import {
  generateRandomId,
  userExists,
  saveUserToStorage,
  getUsersFromStorage,
  updateUserInStorage,
  deleteUserFromStorage,
  User
} from '../storageService'

const someUserUpdate: any = {
  name: 'John'
}
const someUser: User = {
  id: 'iddd',
  source: 'jest',
  name: 'userrr',
  email: 'test@test.com'
}
const someUserTable = {
  Email: { _: 'test@test.com' },
  Name: { _: 'userrr' },
  PartitionKey: { _: 'jest' },
  RowKey: { _: 'iddd' }
}
const someUserTableObject: any = {
  Email: 'test@test.com',
  Name: 'userrr',
  PartitionKey: 'jest',
  Role: undefined,
  RowKey: 'iddd'
}

const setFunctionsMock = (fns: any[], result: any) => {
  fns.map(fn => setFunctionMock(fn, result))
}

const setFunctionMock = (fn: any, result: any) => {
  fn.mockImplementation(jest.fn(result))
}

let queryWhere = jest.fn()

beforeEach(() => {
  jest.resetAllMocks()
  setFunctionMock(getEntityGenerator, () => {
    return {
      String: (x: any) => {
        return x ? { _: x } : undefined
      }
    }
  })
  queryWhere = jest.fn()
  setFunctionMock(Query, () => {
    const where = { where: queryWhere }
    return { ...where, top: () => where }
  })
  setFunctionsMock(
    [QueryTable, TranslateToObject, UpsertTable, CreateTableIfNotExists, DeleteEntity],
    () => {}
  )
})

describe('data/users:', () => {
  describe('storageService:', () => {
    describe('generateRandomId():', () => {
      it('generates random string', () => {
        const mockMath = Object.create(global.Math)
        mockMath.random = () => 0.3456765432
        global.Math = mockMath
        expect(generateRandomId()).toEqual('p7gnu')
      })

      it('generates empty string... which is bad', () => {
        const mockMath = Object.create(global.Math)
        mockMath.random = () => 0
        global.Math = mockMath
        expect(generateRandomId()).toEqual('')
      })
    })

    describe('userExists():', () => {
      it('returns false', async done => {
        setFunctionMock(TranslateToObject, (): any => [])

        const res = await userExists('testtt', 'test@test.com')

        expect(res).toEqual(false)

        done()
      })

      it('returns true', async done => {
        setFunctionMock(TranslateToObject, (): any => [{ user: 'awesome user' }])

        const res = await userExists('testtt', 'test@test.com')

        expect(res).toEqual(true)

        done()
      })
    })

    describe('saveUserToStorage():', () => {
      it('throws error because user already exists', async done => {
        setFunctionMock(TranslateToObject, (): any => [{ user: 'super awesome user' }])

        try {
          const res = await saveUserToStorage(someUser)
          expect(saveUserToStorage).toThrowError()
        } catch (err) {
          expect(err).toEqual('User userrr with email test@test.com already exists.')
        }
        expect(UpsertTable).not.toBeCalled()

        done()
      })

      it('throws error because failed to upsert', async done => {
        setFunctionMock(TranslateToObject, (): any => [])
        setFunctionMock(UpsertTable, () => {
          throw 'test error'
        })

        try {
          const res = await saveUserToStorage(someUser)
          expect(saveUserToStorage).toThrowError()
        } catch (err) {
          expect(err).toEqual('test error')
        }
        expect(CreateTableIfNotExists).toBeCalled()
        expect(UpsertTable).toBeCalledWith('User', someUserTable, 'replace')

        done()
      })

      it('saves successfully, returns user', async done => {
        try {
          const res = await saveUserToStorage(someUser)
          expect(res).toEqual(someUser)
        } catch (err) {
          expect(saveUserToStorage).not.toThrowError()
        }
        expect(CreateTableIfNotExists).toBeCalled()
        expect(UpsertTable).toBeCalledWith('User', someUserTable, 'replace')

        done()
      })
    })

    describe('getUsersFromStorage():', () => {
      it('returns users', async done => {
        setFunctionMock(TranslateToObject, () => [someUserTableObject])

        const res = await getUsersFromStorage()

        expect(res).toEqual([someUser])

        done()
      })
    })

    describe('deleteUserFromStorage():', () => {
      it('throws error because user doesnt exist', async done => {
        setFunctionMock(
          TranslateToObject,
          (): any => {
            throw 'test error'
          }
        )

        try {
          const res = await deleteUserFromStorage('testtt')
          expect(res).toEqual("User testtt doesn't exist")
        } catch (err) {
          expect(deleteUserFromStorage).not.toThrowError()
        }
        expect(DeleteEntity).not.toBeCalled()

        done()
      })

      it('throws error because found user has no PartitionKey', async done => {
        setFunctionMock(TranslateToObject, (): any => [{ PartitionKey: '' }])

        try {
          const res = await deleteUserFromStorage('testtt')
          expect(res).toEqual("User testtt doesn't exist")
        } catch (err) {
          expect(deleteUserFromStorage).not.toThrowError()
        }
        expect(DeleteEntity).not.toBeCalled()

        done()
      })

      it('throws Error because failed to delete entity', async done => {
        setFunctionMock(TranslateToObject, (): any => [{ PartitionKey: '12345' }])
        setFunctionMock(
          DeleteEntity,
          (): any => {
            throw 'test error test error'
          }
        )

        try {
          const res = await deleteUserFromStorage('testtt')
          expect(deleteUserFromStorage).toThrowError()
        } catch (err) {
          expect(err).toMatchObject(
            new Error('Could not delete user testtt: test error test error')
          )
        }
        expect(DeleteEntity).toBeCalledWith('User', '12345', 'testtt')

        done()
      })

      it('deletes user', async done => {
        setFunctionMock(TranslateToObject, (): any => [{ PartitionKey: '12345' }])

        try {
          const res = await deleteUserFromStorage('testtt')
          expect(res).toBeUndefined()
        } catch (err) {
          expect(deleteUserFromStorage).toThrowError()
        }
        expect(DeleteEntity).toBeCalledWith('User', '12345', 'testtt')

        done()
      })
    })

    describe('updateUserInStorage():', () => {
      it('throws error because did not find user', async done => {
        setFunctionMock(
          QueryTable,
          (): any => {
            entries: []
          }
        )

        try {
          const res = await updateUserInStorage('testtt', someUserUpdate)
          expect(updateUserInStorage).toThrowError()
        } catch (err) {
          expect(err).toEqual("User testtt doesn't exist")
        }
        expect(UpsertTable).not.toBeCalled()

        done()
      })

      it('throws error because failed to upsert', async done => {
        setFunctionMock(
          QueryTable,
          (x: any): any => {
            return { entries: [someUserTable] }
          }
        )
        setFunctionMock(UpsertTable, () => {
          throw 'test error'
        })

        try {
          const res = await updateUserInStorage('testtt', someUserUpdate)
          expect(updateUserInStorage).toThrowError()
        } catch (err) {
          expect(err).toEqual('test error')
        }
        expect(UpsertTable).toBeCalledWith('User', someUserTable, 'replace')

        done()
      })

      it('returns new updated user', async done => {
        setFunctionMock(
          TranslateToObject,
          (x: any): any => {
            console.log(JSON.stringify(x.entries, undefined, ' '))
            return [{ ...someUserTableObject, Name: x.entries[0].Name._ }]
          }
        )
        setFunctionMock(
          QueryTable,
          (x: any): any => {
            return { entries: [someUserTable] }
          }
        )

        try {
          const res = await updateUserInStorage('testtt', someUserUpdate)
          expect(res).toEqual({ ...someUser, ...someUserUpdate })
        } catch (err) {
          expect(err).toBeUndefined()
          expect(updateUserInStorage).not.toThrowError()
        }
        expect(UpsertTable).toBeCalledWith('User', someUserTable, 'replace')

        done()
      })
    })
  })
})