import Upload from 'react-native-background-upload'

const options = {
  url: 'https://myservice.com/path/to/post',
  path: 'file://path/to/file/on/device',
  method: 'POST',
  type: 'raw',
  headers: {
    'content-type': 'application/octet-stream', // Customize content-type
    'my-custom-header': 's3headervalueorwhateveryouneed'
  }
}

Upload.startUpload(options).then((uploadId) => {
  console.log('Upload started')
  Upload.addListener('progress', uploadId, (data) => {
    console.log(`Progress: ${data.progress}%`)
  })
  Upload.addListener('error', uploadId, (data) => {
    console.log(`Error: ${data.error}%`)
  })
  Upload.addListener('cancelled', uploadId, (data) => {
    console.log(`Cancelled!`)
  })
  Upload.addListener('completed', uploadId, (data) => {
    // data includes responseCode: number, responseBody: Object, responseHeaders: Lower cased http headers
    console.log('Completed!')
  })
}).catch((err) => {
  console.log('Upload error!', err)
})

import RNBackgroundUpload from 'react-native-background-upload';

const resolveUpload = function(uploadId){
  return new Promise((resolve, reject) => {
    let l1 = RNBackgroundUpload.addListener('error', uploadId, (data) => {
      reject(data);
      cleanup();
    });
    let l2 = RNBackgroundUpload.addListener('cancelled', uploadId, (data) => {
      reject(data);
      cleanup();
    });
    let l3 = RNBackgroundUpload.addListener('completed', uploadId, (data) => {
      resolve(data);
      cleanup();
    });
    let cleanup = () => {
      l1.remove(); l2.remove(); l3.remove();
    }
  });
}

const headers = {
  'Authorization': authString,
  'Content-Type': 'multipart/form-data'
}

const uploadUrl = 'some url';
const uri = 'file://path/to/file';
const formData = {
  someKey: 'someValue'
};

const options = {
  url: uploadUrl,
  path: uri || undefined,
  method: 'POST',
  field: 'fileData',
  headers: headers,
  type: 'multipart',
  parameters: formData,
  customUploadId: `u-${new Date().getTime()}`
}

let res;
let responseData = null;

try{
  await RNBackgroundUpload.startUpload(options);
  res = await resolveUpload(options.customUploadId);

}
catch(err){
  throw {
    status: -1,
    _error: err,
    data: {
      'code':null,
      'detail': null,
      'message': "Network error"
    }
  };
}

responseData = res.responseBody;


if(res.responseCode >= 400){
  throw {
    _error: res,
    status: res.responseCode,
    data: api.processError(responseData)
  };
}
else{
  return {
    data: responseData,
    status: res.responseCode,
    _response: res
  }
}

import { addListener, startUpload, canSuspendIfBackground } from 'react-native-background-upload';

function listenForUploadCompletion(uploadId) {
  return new Promise((resolve, reject) => {
    addListener('error', uploadId, reject);
    addListener('cancelled', uploadId, () => reject(new Error('upload cancelled')));
    addListener('completed', uploadId, ({ responseCode, responseBody }) => {
      if (200 <= responseCode && responseCode <= 299) {
          resolve(uploadId);
      } else {
          reject(new Error(`Could not upload file (${responseCode}):\n${responseBody}`));
      }
    });
  });
}

async function uploadFilesWhileInBackground(url, files) {
  const uploadIds = await Promise.all(files.map(path => startUpload({ path, url })));
  const didUploadPromise = Promise.all(uploadIds.map(id => listenForUploadCompletion(id)));
  // suspend after event listeners are added
  canSuspendIfBackground();
  try {
    await didUploadPromise;
    // update the app UI
  } catch (e) {
    // handle error (show alert, present local notification, etc)
  }
  canSuspendIfBackground();
}

import RNBackgroundUpload from 'react-native-background-upload';

async function uploadFile(url, fileURI) {
  const uploadId = await RNBackgroundUpload.startUpload({ url, path: fileURI, method: 'POST' });
  return new Promise((resolve, reject) => {
    RNBackgroundUpload.addListener('error', uploadId, reject);
    RNBackgroundUpload.addListener('cancelled', uploadId, () => reject(new Error('upload cancelled')));
    RNBackgroundUpload.addListener('completed', uploadId, ({ responseCode, responseBody }) => {
      if (200 <= responseCode && responseCode <= 299) {
          resolve(uploadId);
      } else {
          reject(new Error(`Could not upload file (${responseCode}):\n${responseBody}`));
      }
    });
  });
}

async function uploadManyFilesThenPOST(files) {
  try {
    await Promise.all(files.map(fileURI => uploadFile('https://example.com/upload', fileURI)));
    const response = await fetch('https://example.com/confirmUploads', { method: 'POST' });
    if (!response.ok) throw new Error('Could not confirm uploads');
  } catch (error) {
    const response = await fetch('https://example.com/failedUploads', { method: 'POST' });
    if (!response.ok) throw new Error('Could not report failed uploads');
  }
  RNBackgroundUpload.canSuspendIfBackground();
}

import RNBackgroundUpload from 'react-native-background-upload';

// Request background time. Do not call this on app suspend/resume since it might be already too late.
let taskId = await RNBackgroundUpload.beginBackgroundTask();

// Listen to background time is about to expire events. You can do some cleanup here. You will have about 3 to 4 seconds to run code
// before the app goes to sleep
let bgExpiredRelease = RNBackgroundUpload.addListener('bgExpired', null, (data) => {
  if(this.working && (!taskId || data.id == taskId)){
    // do some cleanup
  }
});

// run background code, do uploads, or even regular fetch requests

// tell the OS we are done. If you don't call this, your app will still be put to sleep internally
// to avoid it from being killed
if(taskId !== null){
  await RNBackgroundUpload.endBackgroundTask(taskId);
}
if(bgExpiredRelease){
  bgExpiredRelease.remove();
}