import types from '../types'

/*
  Note:
  This is a sub-reducer intended to process the folder-file API output from the DB.
  Please run this from inside your module reducers :) 
*/

const datasetInitialState = () => ({
  loading: true,
  progress: null,
  error: null,
  data: null,
  folder_id: 0,
})

const datasetReducer = (state = datasetInitialState(), action) => {
  switch(action.type) {
    case types.app.load_progress:
      return {
        ...state,
        progress: action.progress
      }

    case types.dataset.load:
      return {
        ...state,
        loading: false,
        data: action.data,
      }

    case types.dataset.set_folder:
      return {
        ...state,
        folder_id: action.data.folder_id,
      }

    case types.folder.create:
      return {
        ...state,
        loading: false,
        data: {
          folders: state.data.folders.concat([action.data.id]),
          folderLookup: {
            ...state.data.folderLookup,
            [action.data.id]: action.data,
          }
        },
      }
      return state

    case types.file.create:
      return handleFileCreate(state, action)

    case types.file.update:
      return handleFileUpdate(state, action)

    case types.file.destroy:
      return handleFileDestroy(state, action)

    case types.dataset.list_epochs:
      return {
        ...state,
        data: {
          ...state.data,
          epochs: action.data.epochs,
        }
      }

    default:
      return state
  }
}


function handleFileCreate(state, action){
  console.log(action.data)
  if (! state.data || !state.data.datasetLookup) return state
  let dataset, old_dataset, folder, old_folder
  let dataset_name
  if (action.data.dataset) {
    dataset_name = action.data.dataset
  }
  else if (action.data.name) {
    dataset_name = action.data.name.split('.')[0]
  }
  else if (action.data.url) {
    dataset_name = action.data.url
  }
  else {
    dataset_name = null
  }
  if (dataset_name in state.data.datasetLookup) {
    old_dataset = state.data.datasetLookup[dataset_name]
    dataset = {
      ...old_dataset,
      input: action.data.generated ? old_dataset.input : [action.data.id].concat(old_dataset.input),
      output: !action.data.generated ? old_dataset.output : [action.data.id].concat(old_dataset.output),
    }
  } else {
    console.log(action.data.created_at, action.data.date)
    dataset = {
      name: dataset_name,
      date: action.data.created_at || action.data.date,
      input: action.data.generated ? [] : [action.data.id],
      checkpoints: [],
      output: !action.data.generated ? [] : [action.data.id],
    }
  }
  old_folder = state.data.folderLookup[action.data.folder_id]
  folder = {
    ...old_folder,
    datasets: old_folder.datasets.concat([dataset_name]),
    files: old_folder.files.concat([action.data.id]),
  }
  return {
    ...state,
    loading: false,
    data: {
      ...state.data,
      files: state.data.files.concat([action.data.id]),
      folderLookup: {
        ...state.data.folderLookup,
        [action.data.folder_id]: folder,
      },
      fileLookup: {
        ...state.data.fileLookup,
        [action.data.id]: action.data,
      },
      datasetLookup: {
        ...state.data.datasetLookup,
        [dataset_name]: dataset,
      },
    }
  }
}

function handleFileUpdate(state, action){
  let old_dataset;
  let new_dataset = state.data.datasetLookup[action.data.dataset]
  let old_file = state.data.fileLookup[action.data.id]
  let new_dataset_update;
  if (old_file && action.data.dataset !== old_file.dataset) {
    if (state.data.datasetLookup[old_file.dataset]) {
      old_dataset = state.data.datasetLookup[old_file.dataset]
      old_dataset_update = {
        ...old_dataset,
        input: old_dataset.input.filter(id => id !== action.data.id),
        output: old_dataset.output.filter(id => id !== action.data.id),
      }
    }
    new_dataset_update = {
      ...new_dataset,
      input: action.data.generated ? [] : [action.data.id],
      output: !action.data.generated ? [] : [action.data.id],
    }
  }
  console.log('old_dataset', old_dataset_update.name)
  console.log('new_dataset', new_dataset_update.name)
  return {
    ...state,
    loading: false,
    data: {
      ...state.data,
      datasetLookup: old_dataset ? {
        ...state.data.datasetLookup,
        [old_dataset.name]: old_dataset_update,
        [new_dataset.name]: new_dataset_update,
      } : new_dataset_update ? {
        ...state.data.datasetLookup,
        [new_dataset.name]: new_dataset_update,
      } : state.data.datasetLookup,
      fileLookup: {
        ...state.data.fileLookup,
        [action.data.id]: action.data,
      },  
    }
  }
  return state
}

function handleFileDestroy(state, action){
  if (! state.data) return state
  // delete the key from fileLookup
  let fileLookup = {
    ...state.data.fileLookup
  }
  let datasetLookup = {
    ...state.data.datasetLookup
  }
  let folderLookup = {
    ...state.data.folderLookup
  }
  let old_file = fileLookup[action.data.id]
  if (!old_file) return state
  let old_dataset = state.data.datasetLookup[old_file.dataset]
  let dataset
  if (old_dataset) {
    dataset = {
      ...old_dataset,
      input: old_dataset.input.filter(id => id !== old_file.id),
      output: old_dataset.output.filter(id => id !== old_file.id),
    }
    if (! dataset.input.length && ! dataset.checkpoints.length && ! dataset.output.length) {
      delete datasetLookup[old_file.dataset]
      let old_folder = folderLookup[old_file.folder_id]
      folderLookup[old_file.folder_id] = {
        ...old_folder,
        datasets: old_folder.datasets.filter(name => name !== old_file.dataset)
      }
    } else {
      console.log('dataset just needs sweeping')
      datasetLookup[old_file.dataset] = dataset
    }
  }
  delete fileLookup[old_file.id]

  return {
    ...state,
    loading: false,
    data: {
      ...state.data,
      folderLookup,
      fileLookup,
      datasetLookup,
    }
  }
}

export default datasetReducer