import types from '../../types'

const samplernnInitialState = {
  loading: true,
  progress: { i: 0, n: 0 },
  error: null,
  folders: [],
  folder_id: 0,
  data: null,
  lossReport: null,
}

const samplernnReducer = (state = samplernnInitialState, action) => {
  // console.log(action.type)
  switch(action.type) {
    case types.samplernn.init:
      return {
        ...state,
        loading: false,
        data: action.data,
      }

    case types.socket.connect:
      return {
        ...state,
      }

    case types.task.task_begin:
      return {
        ...state,
      }

    case types.task.task_finish:
      return {
        ...state,
      }

    // so now the last thing is to figure out how to access things inside these datasets
    // and rebuild them if need be, considering this is SUPER awkward inside of redux.
    
    case types.folder.create:
      if (action.data.module === 'samplernn') {
        return {
          ...state,
          loading: false,
          data: {
            folders: state.data.folders.concat([action.data.id]),
            folderLookup: {
              ...state.data.folderLookup,
              [action.data.id]: action.data,
            }
          },
          folder: {
            ...action.data,
            datasets: [],
            files: [],
          },
        }
      }
      return state

    case types.file.create:
      if (action.data.module === 'samplernn') {
        console.log(action.data)
        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,
            },
          }
        }
      }
      return state

    case types.file.update:
      console.log('>>>>>>> file update')
      if (action.data.module === 'samplernn') {
        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

    case types.file.destroy:
      if (action.data.module === 'samplernn') {
        // delete 
        const { [action.data.id]: removedFile, ...fileLookup } = state.data.fileLookup
        return {
          ...state,
          loading: false,
          data: {
            ...state.data,
            fileLookup,
          }
        }
      }
      return state

    case types.socket.status:
      return samplernnSocket(state, action.data)

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

    case types.samplernn.load_loss:
      return {
        ...state,
        lossReport: action.lossReport,
      }

    case types.app.load_progress:
      return {
        ...state,
        progress: action.progress
      }

    default:
      return state
  }
}

const samplernnSocket = (state, action) => {
  console.log(action)
  switch (action.key) {
    case 'list_directory':
      return state
    default:
      return state
  }
}

export default samplernnReducer