import {
  createContext,
  useCallback,
  useMemo,
  useReducer,
  useContext,
  useEffect,
  useState,
  FC,
} from 'react'

import { mapSeries } from '../../../infrastructure/promise'

import {
  syncRename,
  syncDelete,
  syncMove,
  syncCreateEntity,
} from '../util/sync-mutation'
import { findInTree, findInTreeOrThrow } from '../util/find-in-tree'
import { isNameUniqueInFolder } from '../util/is-name-unique-in-folder'
import { isBlockedFilename, isCleanFilename } from '../util/safe-path'

import { useProjectContext } from '../../../shared/context/project-context'
import { useEditorContext } from '../../../shared/context/editor-context'
import { useFileTreeData } from '../../../shared/context/file-tree-data-context'
import { useFileTreeSelectable } from './file-tree-selectable'

import {
  InvalidFilenameError,
  BlockedFilenameError,
  DuplicateFilenameError,
  DuplicateFilenameMoveError,
} from '../errors'
import { Folder } from '../../../../../types/folder'

const FileTreeActionableContext = createContext<
  | {
      isDeleting: boolean
      isRenaming: boolean
      isCreatingFile: boolean
      isCreatingFolder: boolean
      isMoving: boolean
      inFlight: boolean
      actionedEntities: any | null
      newFileCreateMode: any | null
      error: any | null
      canDelete: boolean
      canRename: boolean
      canCreate: boolean
      parentFolderId: string
      isDuplicate: (parentFolderId: string, name: string) => boolean
      startRenaming: any
      finishRenaming: any
      startDeleting: any
      finishDeleting: any
      finishMoving: any
      startCreatingFile: any
      startCreatingFolder: any
      finishCreatingFolder: any
      startCreatingDocOrFile: any
      startUploadingDocOrFile: any
      finishCreatingDoc: any
      finishCreatingLinkedFile: any
      cancel: () => void
      droppedFiles: { files: any; targetFolderId: string } | null
      setDroppedFiles: (files: any) => void
      downloadPath?: string
    }
  | undefined
>(undefined)

/* eslint-disable no-unused-vars */
enum ACTION_TYPES {
  START_RENAME = 'START_RENAME',
  START_DELETE = 'START_DELETE',
  DELETING = 'DELETING',
  START_CREATE_FILE = 'START_CREATE_FILE',
  START_CREATE_FOLDER = 'START_CREATE_FOLDER',
  CREATING_FILE = 'CREATING_FILE',
  CREATING_FOLDER = 'CREATING_FOLDER',
  MOVING = 'MOVING',
  CANCEL = 'CANCEL',
  CLEAR = 'CLEAR',
  ERROR = 'ERROR',
}
/* eslint-enable no-unused-vars */

type State = {
  isDeleting: boolean
  isRenaming: boolean
  isCreatingFile: boolean
  isCreatingFolder: boolean
  isMoving: boolean
  inFlight: boolean
  actionedEntities: any | null
  newFileCreateMode: any | null
  error: unknown | null
}

const defaultState: State = {
  isDeleting: false,
  isRenaming: false,
  isCreatingFile: false,
  isCreatingFolder: false,
  isMoving: false,
  inFlight: false,
  actionedEntities: null,
  newFileCreateMode: null,
  error: null,
}

function fileTreeActionableReadOnlyReducer(state: State) {
  return state
}

type Action =
  | {
      type: ACTION_TYPES.START_RENAME
    }
  | {
      type: ACTION_TYPES.START_DELETE
      actionedEntities: any | null
    }
  | {
      type: ACTION_TYPES.START_CREATE_FILE
      newFileCreateMode: any | null
    }
  | {
      type: ACTION_TYPES.START_CREATE_FOLDER
    }
  | {
      type: ACTION_TYPES.CREATING_FILE
    }
  | {
      type: ACTION_TYPES.CREATING_FOLDER
    }
  | {
      type: ACTION_TYPES.DELETING
    }
  | {
      type: ACTION_TYPES.MOVING
    }
  | {
      type: ACTION_TYPES.CLEAR
    }
  | {
      type: ACTION_TYPES.CANCEL
    }
  | {
      type: ACTION_TYPES.ERROR
      error: unknown
    }

function fileTreeActionableReducer(state: State, action: Action) {
  switch (action.type) {
    case ACTION_TYPES.START_RENAME:
      return { ...defaultState, isRenaming: true }
    case ACTION_TYPES.START_DELETE:
      return {
        ...defaultState,
        isDeleting: true,
        actionedEntities: action.actionedEntities,
      }
    case ACTION_TYPES.START_CREATE_FILE:
      return {
        ...defaultState,
        isCreatingFile: true,
        newFileCreateMode: action.newFileCreateMode,
      }
    case ACTION_TYPES.START_CREATE_FOLDER:
      return { ...defaultState, isCreatingFolder: true }
    case ACTION_TYPES.CREATING_FILE:
      return {
        ...defaultState,
        isCreatingFile: true,
        newFileCreateMode: state.newFileCreateMode,
        inFlight: true,
      }
    case ACTION_TYPES.CREATING_FOLDER:
      return { ...defaultState, isCreatingFolder: true, inFlight: true }
    case ACTION_TYPES.DELETING:
      // keep `actionedEntities` so the entities list remains displayed in the
      // delete modal
      return {
        ...defaultState,
        isDeleting: true,
        inFlight: true,
        actionedEntities: state.actionedEntities,
      }
    case ACTION_TYPES.MOVING:
      return {
        ...defaultState,
        isMoving: true,
        inFlight: true,
      }
    case ACTION_TYPES.CLEAR:
      return { ...defaultState }
    case ACTION_TYPES.CANCEL:
      if (state.inFlight) return state
      return { ...defaultState }
    case ACTION_TYPES.ERROR:
      return { ...state, inFlight: false, error: action.error }
    default:
      throw new Error(`Unknown user action type: ${(action as Action).type}`)
  }
}

export const FileTreeActionableProvider: FC<{
  reindexReferences: () => void
}> = ({ reindexReferences, children }) => {
  const { _id: projectId } = useProjectContext()
  const { permissionsLevel } = useEditorContext()

  const [state, dispatch] = useReducer(
    permissionsLevel === 'readOnly'
      ? fileTreeActionableReadOnlyReducer
      : fileTreeActionableReducer,
    defaultState
  )

  const { fileTreeData, dispatchRename, dispatchMove } = useFileTreeData()
  const { selectedEntityIds, isRootFolderSelected } = useFileTreeSelectable()

  const [droppedFiles, setDroppedFiles] = useState(null)

  const startRenaming = useCallback(() => {
    dispatch({ type: ACTION_TYPES.START_RENAME })
  }, [])

  // update the entity with the new name immediately in the tree, but revert to
  // the old name if the sync fails
  const finishRenaming = useCallback(
    (newName: string) => {
      const selectedEntityId = Array.from(selectedEntityIds)[0]
      const found = findInTreeOrThrow(fileTreeData, selectedEntityId)
      const oldName = found.entity.name
      if (newName === oldName) {
        return dispatch({ type: ACTION_TYPES.CLEAR })
      }

      const error = validateRename(fileTreeData, found, newName)
      if (error) return dispatch({ type: ACTION_TYPES.ERROR, error })

      dispatch({ type: ACTION_TYPES.CLEAR })
      dispatchRename(selectedEntityId, newName)
      return syncRename(projectId, found.type, found.entity._id, newName).catch(
        error => {
          dispatchRename(selectedEntityId, oldName)
          // The state from this error action isn't used anywhere right now
          // but we need to handle the error for linting
          dispatch({ type: ACTION_TYPES.ERROR, error })
        }
      )
    },
    [dispatchRename, fileTreeData, projectId, selectedEntityIds]
  )

  const isDuplicate = useCallback(
    (parentFolderId: string, name: string) => {
      return !isNameUniqueInFolder(fileTreeData, parentFolderId, name)
    },
    [fileTreeData]
  )

  // init deletion flow (this will open the delete modal).
  // A copy of the selected entities is set as `actionedEntities` so it is kept
  // unchanged as the entities are deleted and the selection is updated
  const startDeleting = useCallback(() => {
    const actionedEntities = Array.from(selectedEntityIds).map(
      entityId => findInTreeOrThrow(fileTreeData, entityId).entity
    )
    dispatch({ type: ACTION_TYPES.START_DELETE, actionedEntities })
  }, [fileTreeData, selectedEntityIds])

  // deletes entities in series. Tree will be updated via the socket event
  const finishDeleting = useCallback(() => {
    dispatch({ type: ACTION_TYPES.DELETING })
    let shouldReindexReferences = false

    return (
      mapSeries(Array.from(selectedEntityIds), id => {
        const found = findInTreeOrThrow(fileTreeData, id)
        shouldReindexReferences =
          shouldReindexReferences || /\.bib$/.test(found.entity.name)
        return syncDelete(projectId, found.type, found.entity._id).catch(
          error => {
            // throw unless 404
            if (error.info.statusCode !== 404) {
              throw error
            }
          }
        )
      })
        // @ts-ignore (TODO: improve mapSeries types)
        .then(() => {
          if (shouldReindexReferences) {
            reindexReferences()
          }
          dispatch({ type: ACTION_TYPES.CLEAR })
        })
        .catch((error: Error) => {
          // set an error and allow user to retry
          dispatch({ type: ACTION_TYPES.ERROR, error })
        })
    )
  }, [fileTreeData, projectId, selectedEntityIds, reindexReferences])

  // moves entities. Tree is updated immediately and data are sync'd after.
  const finishMoving = useCallback(
    (toFolderId, draggedEntityIds) => {
      dispatch({ type: ACTION_TYPES.MOVING })

      // find entities and filter out no-ops and nested files
      const founds = Array.from(draggedEntityIds)
        .map(draggedEntityId =>
          findInTreeOrThrow(fileTreeData, draggedEntityId)
        )
        .filter(
          found =>
            found.parentFolderId !== toFolderId &&
            !draggedEntityIds.has(found.parentFolderId)
        )

      // make sure all entities can be moved, return early otherwise
      const isMoveToRoot = toFolderId === fileTreeData._id
      const validationError = founds
        .map(found =>
          validateMove(fileTreeData, toFolderId, found, isMoveToRoot)
        )
        .find(error => error)
      if (validationError) {
        return dispatch({ type: ACTION_TYPES.ERROR, error: validationError })
      }

      // keep track of old parent folder ids so we can revert entities if sync fails
      const oldParentFolderIds: Record<string, string> = {}
      let isMoveFailed = false

      // dispatch moves immediately
      founds.forEach(found => {
        oldParentFolderIds[found.entity._id] = found.parentFolderId
        dispatchMove(found.entity._id, toFolderId)
      })

      // sync dispatched moves after
      return (
        mapSeries(founds, async found => {
          try {
            await syncMove(projectId, found.type, found.entity._id, toFolderId)
          } catch (error) {
            isMoveFailed = true
            dispatchMove(found.entity._id, oldParentFolderIds[found.entity._id])
            dispatch({ type: ACTION_TYPES.ERROR, error })
          }
        })
          // @ts-ignore (TODO: improve mapSeries types)
          .then(() => {
            if (!isMoveFailed) {
              dispatch({ type: ACTION_TYPES.CLEAR })
            }
          })
      )
    },
    [dispatchMove, fileTreeData, projectId]
  )

  const startCreatingFolder = useCallback(() => {
    dispatch({ type: ACTION_TYPES.START_CREATE_FOLDER })
  }, [])

  const parentFolderId = useMemo(() => {
    return getSelectedParentFolderId(
      fileTreeData,
      selectedEntityIds,
      isRootFolderSelected
    )
  }, [fileTreeData, selectedEntityIds, isRootFolderSelected])

  const finishCreatingEntity = useCallback(
    entity => {
      const error = validateCreate(fileTreeData, parentFolderId, entity)
      if (error) {
        return Promise.reject(error)
      }

      return syncCreateEntity(projectId, parentFolderId, entity)
    },
    [fileTreeData, parentFolderId, projectId]
  )

  const finishCreatingFolder = useCallback(
    name => {
      dispatch({ type: ACTION_TYPES.CREATING_FOLDER })
      return finishCreatingEntity({ endpoint: 'folder', name })
        .then(() => {
          dispatch({ type: ACTION_TYPES.CLEAR })
        })
        .catch(error => {
          dispatch({ type: ACTION_TYPES.ERROR, error })
        })
    },
    [finishCreatingEntity]
  )

  const startCreatingFile = useCallback(newFileCreateMode => {
    dispatch({ type: ACTION_TYPES.START_CREATE_FILE, newFileCreateMode })
  }, [])

  const startCreatingDocOrFile = useCallback(() => {
    startCreatingFile('doc')
  }, [startCreatingFile])

  const startUploadingDocOrFile = useCallback(() => {
    startCreatingFile('upload')
  }, [startCreatingFile])

  const finishCreatingDocOrFile = useCallback(
    entity => {
      dispatch({ type: ACTION_TYPES.CREATING_FILE })

      return finishCreatingEntity(entity)
        .then(() => {
          dispatch({ type: ACTION_TYPES.CLEAR })
        })
        .catch(error => {
          dispatch({ type: ACTION_TYPES.ERROR, error })
        })
    },
    [finishCreatingEntity]
  )

  const finishCreatingDoc = useCallback(
    entity => {
      entity.endpoint = 'doc'
      return finishCreatingDocOrFile(entity)
    },
    [finishCreatingDocOrFile]
  )

  const finishCreatingLinkedFile = useCallback(
    entity => {
      entity.endpoint = 'linked_file'
      return finishCreatingDocOrFile(entity)
    },
    [finishCreatingDocOrFile]
  )

  const cancel = useCallback(() => {
    dispatch({ type: ACTION_TYPES.CANCEL })
  }, [])

  // listen for `file-tree.start-creating` events
  useEffect(() => {
    function handleEvent(event: Event) {
      dispatch({
        type: ACTION_TYPES.START_CREATE_FILE,
        newFileCreateMode: (event as CustomEvent<{ mode: string }>).detail.mode,
      })
    }

    window.addEventListener('file-tree.start-creating', handleEvent)

    return () => {
      window.removeEventListener('file-tree.start-creating', handleEvent)
    }
  }, [])

  // build the path for downloading a single file
  const downloadPath = useMemo(() => {
    if (selectedEntityIds.size === 1) {
      const [selectedEntityId] = selectedEntityIds
      const selectedEntity = findInTree(fileTreeData, selectedEntityId)
      if (selectedEntity?.type === 'fileRef') {
        return `/project/${projectId}/file/${selectedEntityId}`
      }
    }
  }, [fileTreeData, projectId, selectedEntityIds])

  // TODO: wrap in useMemo
  const value = {
    canDelete: selectedEntityIds.size > 0 && !isRootFolderSelected,
    canRename: selectedEntityIds.size === 1 && !isRootFolderSelected,
    canCreate: selectedEntityIds.size < 2,
    ...state,
    parentFolderId,
    isDuplicate,
    startRenaming,
    finishRenaming,
    startDeleting,
    finishDeleting,
    finishMoving,
    startCreatingFile,
    startCreatingFolder,
    finishCreatingFolder,
    startCreatingDocOrFile,
    startUploadingDocOrFile,
    finishCreatingDoc,
    finishCreatingLinkedFile,
    cancel,
    droppedFiles,
    setDroppedFiles,
    downloadPath,
  }

  return (
    <FileTreeActionableContext.Provider value={value}>
      {children}
    </FileTreeActionableContext.Provider>
  )
}

export function useFileTreeActionable() {
  const context = useContext(FileTreeActionableContext)

  if (!context) {
    throw new Error(
      'useFileTreeActionable is only available inside FileTreeActionableProvider'
    )
  }

  return context
}

function getSelectedParentFolderId(
  fileTreeData: Folder,
  selectedEntityIds: Set<string>,
  isRootFolderSelected: boolean
) {
  if (isRootFolderSelected) {
    return fileTreeData._id
  }

  // we expect only one entity to be selected in that case, so we pick the first
  const selectedEntityId = Array.from(selectedEntityIds)[0]
  if (!selectedEntityId) {
    // in some cases no entities are selected. Return the root folder id then.
    return fileTreeData._id
  }

  const found = findInTree(fileTreeData, selectedEntityId)

  if (!found) {
    // if the entity isn't in the tree, return the root folder id.
    return fileTreeData._id
  }

  return found.type === 'folder' ? found.entity._id : found.parentFolderId
}

function validateCreate(
  fileTreeData: Folder,
  parentFolderId: string,
  entity: { name: string; endpoint: string }
) {
  if (!isCleanFilename(entity.name)) {
    return new InvalidFilenameError()
  }

  if (!isNameUniqueInFolder(fileTreeData, parentFolderId, entity.name)) {
    return new DuplicateFilenameError()
  }

  // check that the name of a file is allowed, if creating in the root folder
  const isMoveToRoot = parentFolderId === fileTreeData._id
  const isFolder = entity.endpoint === 'folder'
  if (isMoveToRoot && !isFolder && isBlockedFilename(entity.name)) {
    return new BlockedFilenameError()
  }
}

function validateRename(
  fileTreeData: Folder,
  found: { parentFolderId: string; path: string; type: string },
  newName: string
) {
  if (!isCleanFilename(newName)) {
    return new InvalidFilenameError()
  }

  if (!isNameUniqueInFolder(fileTreeData, found.parentFolderId, newName)) {
    return new DuplicateFilenameError()
  }

  const isTopLevel = found.path.length === 1
  const isFolder = found.type === 'folder'
  if (isTopLevel && !isFolder && isBlockedFilename(newName)) {
    return new BlockedFilenameError()
  }
}

function validateMove(
  fileTreeData: Folder,
  toFolderId: string,
  found: { entity: { name: string }; type: string },
  isMoveToRoot: boolean
) {
  if (!isNameUniqueInFolder(fileTreeData, toFolderId, found.entity.name)) {
    const error = new DuplicateFilenameMoveError()
    ;(error as DuplicateFilenameMoveError & { entityName: string }).entityName =
      found.entity.name
    return error
  }

  const isFolder = found.type === 'folder'
  if (isMoveToRoot && !isFolder && isBlockedFilename(found.entity.name)) {
    return new BlockedFilenameError()
  }
}