import * as React from 'react';
import AsyncStorage from '@react-native-async-storage/async-storage';
import DeviceInfo from 'react-native-device-info';
import URL from '../api/endpoints.js';

const DBName = "@UnioilLoyaltyApp_";

export const get = async (key) => {
  try {
    const result = await AsyncStorage.getItem(DBName + key)
    return typeof result == 'object' ? JSON.parse(result) : result
  } catch (error) {
    return error
  }
}

export const set = async (key, data, onSuccess, onError) => {
  try {
    const result = await AsyncStorage.setItem(DBName + key, data)
    await onSuccess(result)
  } catch (error) {
    await onError(error)
  }
}

export const reset = async () => {
  try{
    await AsyncStorage.removeItem(DBName + "iqair");
    await AsyncStorage.removeItem(DBName + "pumpPaymentCards");
    await AsyncStorage.removeItem(DBName + "topupPaymentCards");
    await AsyncStorage.setItem(DBName + "session", JSON.stringify([]))
    await AsyncStorage.setItem(DBName + "token", JSON.stringify([]))
    await AsyncStorage.setItem(DBName + "accounts", JSON.stringify([]))
    await AsyncStorage.removeItem(DBName + "enter_mpin")
    await AsyncStorage.removeItem(DBName + "set_mpin")
    await AsyncStorage.removeItem(DBName + "is_token_register")
    await AsyncStorage.removeItem(DBName + "notifications")
  }catch(error){
    return false
  }
}

export const resetSwitchAccount = async () => {
  try {
    await AsyncStorage.removeItem(DBName + "iqair");
    await AsyncStorage.removeItem(DBName + "pumpPaymentCards");
    await AsyncStorage.removeItem(DBName + "topupPaymentCards");
  }catch(error) {
    return false
  }
}

export const session = async () => {
  try {
    const s = await AsyncStorage.getItem(DBName + "session")
    const t = await AsyncStorage.getItem(DBName + "token")
    let sessions = typeof s == 'string' ? JSON.parse(s) : []
    let tokens = typeof t == 'string' ? JSON.parse(t) : []
    let session = sessions.length > 0 ? sessions[sessions.length > 0 ? 0 : sessions.length] : sessions.pop()
    let token = tokens.filter(function(item){ return item.card_number == session.card_number }).map(function(item){ return item })[0].token
    return {user: session, token: token && token.includes("Bearer ") ? token : "Bearer " + token}
  } catch (error) {
    return error
  }
}

export const login = async (data, onSuccess, onError) => {
  try{
    await AsyncStorage.removeItem(DBName + "is_guest")
    const d1 = await AsyncStorage.getItem(DBName + "session")
    const d2 = await AsyncStorage.getItem(DBName + "token")
    let sessions = typeof d1 == 'string' ? JSON.parse(d1) : []
    let tokens  = typeof d2 == 'string' ? JSON.parse(d2) : []
    if(sessions && tokens){
      let filteredSessions = sessions.filter(function(item){
        return item.card_number != data.session.card_number
      }).map(function(item){
          return item
      })
  
      let filteredTokens = tokens.filter(function(item){ 
        return item.card_number != data.session.card_number
      }).map(function(item){ 
        return item 
      })

      filteredSessions.splice(0, 0, {card_number: data.session.card_number, lcard_uuid: data.session.lcard_uuid, mobile_number: data.session.mobile})
      filteredTokens.splice(0, 0, {token: data.token, card_number: data.session.card_number})

      const res_sessions = await AsyncStorage.setItem(DBName + "session", JSON.stringify(filteredSessions))
      const res_tokens = await AsyncStorage.setItem(DBName + "token", JSON.stringify(filteredTokens))
      onSuccess({res_sessions, res_tokens})
      return {res_sessions, res_tokens}
    }
  }catch(error){
    onError(error)
    return error
  }
}

export const setsession = async (data, onSuccess, onError) => {
  try{
    const d1 = await AsyncStorage.getItem(DBName + "session")
    let sessions = typeof d1 == 'string' ? JSON.parse(d1) : []
    if(sessions){
      var filteredSessions = sessions.filter(function(item){
        return item.card_number != data.card_number;
      }).map(function(item){
        return item
      })

      filteredSessions.splice(0, 0, data)
      const res = await AsyncStorage.setItem(DBName + "session", JSON.stringify(filteredSessions))
      onSuccess(res)
    }
  }catch(error){
    onError(error)
  }
}

export const addsession = async (data, onSuccess, onError) => {
  try{
    const acts = await AsyncStorage.getItem(DBName + "session")
    let json = acts ? JSON.parse(acts) : []
    if(json){
      json.push(data)
      let res = await AsyncStorage.setItem(DBName + 'session', JSON.stringify(json))
      onSuccess(res)
    }
  }catch(error){
    onError(error)
  }
}

export const settoken = async (data, onSuccess, onError) => {
  try{
    const d1 = await AsyncStorage.getItem(DBName + "token")
    let tokens = typeof d1 == 'string' ? JSON.parse(d1) : []
    if(tokens){
      tokens.push(data)
      const res = await AsyncStorage.setItem(DBName + "token", JSON.stringify(tokens))
      onSuccess(res)
    }
  }catch(error){
    onError(error)
  }
}

export const accounts = async () => {
  try{
    const ss = await AsyncStorage.getItem(DBName + "session")
    const acts = await AsyncStorage.getItem(DBName + "accounts")
    let json = typeof acts == 'string' ? JSON.parse(acts) : acts
    let sessions = typeof ss == 'string' ? JSON.parse(ss) : ss
    let accounts = []
    for(var i=0;i<sessions.length;i++){
      for(var x=0;x<json.length;x++){    
        if(sessions[i].card_number == json[x].data.card_number) accounts[i] = json[x]
      }
    }
    return json
  }catch(error){
    return error
  }
}

export const removeAccount = async (account, successCallback, errorCallback) => {
  try {
    const ss = await AsyncStorage.getItem(DBName + "session")
    const acts = await AsyncStorage.getItem(DBName + "accounts")
    const t = await AsyncStorage.getItem(DBName + "token")
    let json = typeof acts == 'string' ? JSON.parse(acts) : acts
    let sessions = typeof ss == 'string' ? JSON.parse(ss) : ss
    let tokens = typeof t == 'string' ? JSON.parse(t) : t

    json = json.filter(function(item){
      return item.data.card_number != account.data.card_number;
    }).map(function(item){
        return item
    })

    sessions = sessions.filter(function(item){
      return item.card_number != account.data.card_number
    }).map(function(item){
        return item
    })

    tokens = tokens.filter(function(item){ 
      return item.card_number != account.data.card_number
    }).map(function(item){ 
      return item 
    })

    await AsyncStorage.setItem(DBName + 'session', JSON.stringify(sessions))
    await AsyncStorage.setItem(DBName + 'accounts', JSON.stringify(json))
    await AsyncStorage.setItem(DBName + 'token', JSON.stringify(tokens))
    successCallback()
  } catch (error) {
    errorCallback()
  }
}

export const addaccount = async (data, onSuccess, onError) => {
  try{
    const acts = await AsyncStorage.getItem(DBName + "accounts")
    let json = acts ? JSON.parse(acts) : []
    if(json){
      var filteredJson = json.filter(function(item){
        return item.data.card_number != data.data.card_number;
      }).map(function(item){
        return item
      })
      filteredJson.splice(0, 0, data)
      
      let response = await AsyncStorage.setItem(DBName + 'accounts', JSON.stringify(filteredJson))
      onSuccess(response)
    }
  }catch(error){
    onError(error)
  }
}

export const profile = async () => {
  try{
    const acts = await AsyncStorage.getItem(DBName + "accounts")
    let json = acts ? JSON.parse(acts) : []
    return json.length > 0 ? json[json.length > 0 ? 0 : json.length] : json.pop()
    // return json.pop()
  }catch(error){
    return error
  }
}

export const updateProfile = async (data, onSuccess, onError) => {
  try{
    const acts = await AsyncStorage.getItem(DBName + "accounts")
    const ss = await AsyncStorage.getItem(DBName + "session")
    const t = await AsyncStorage.getItem(DBName + "token")
    let accounts = typeof acts == 'string' ? JSON.parse(acts) : acts
    let sessions = typeof ss == 'string' ? JSON.parse(ss) : ss
    let tokens = typeof t == 'string' ? JSON.parse(t) : t

    var filteredAccounts = accounts.filter(function(item){
      return item.data.card_number != data.data.card_number;
    }).map(function(item){
      return item
    })

    var filteredSessions = sessions.filter(function(item){
      return item.card_number != data.data.card_number;
    }).map(function(item){
      return item
    })

    let filteredTokens = tokens.filter(function(item){ 
      return item.card_number != data.data.card_number
    }).map(function(item){ 
      return item 
    })

    //get the token for saving to first index of array
    let token = tokens.filter(function(item){ 
      return item.card_number == data.data.card_number
    }).map(function(item){ 
      return item 
    })[0].token

    filteredAccounts.splice(0, 0, data)
    filteredSessions.splice(0, 0, {card_number: data.data.card_number, lcard_uuid: data.data.lcard_uuid, mobile_number: data.data.mobile})
    filteredTokens.splice(0, 0, {token: token, card_number: data.data.card_number})

    
    await AsyncStorage.setItem(DBName + 'accounts', JSON.stringify(filteredAccounts))
    await AsyncStorage.setItem(DBName + 'session', JSON.stringify(filteredSessions))
    await AsyncStorage.setItem(DBName + 'token', JSON.stringify(filteredTokens))
    onSuccess()  
  } catch(error) {
    onError(error)
  }
}

export const AddNotification = async (notification) => {
  try{
    let notifications = []
    const allNotifs = await AsyncStorage.getItem(DBName + "notifications")
    if(!allNotifs){
      notifications.push(notification)
      let result = await AsyncStorage.setItem(DBName + "notifications", JSON.stringify(notifications))
      return "Notification successfully added"
    }else{
      notifications = JSON.parse(allNotifs)
      notifications.push(notification)
      let result = await AsyncStorage.setItem(DBName + "notifications", JSON.stringify(notifications))
      return "Notification successfully added"
    }
  }catch(e){
    return e
  }
}

export const remove = async (key) => {
  try{
    const result = await AsyncStorage.removeItem(DBName + key)
  }catch(e){
    return e
  }
}

export const switchaccount = async (index, cn) => {
  const acts = await AsyncStorage.getItem(DBName + "accounts")
  const ss = await AsyncStorage.getItem(DBName + "session")
  const t = await AsyncStorage.getItem(DBName + "token")
  let accounts = typeof acts == 'string' ? JSON.parse(acts) : acts
  let sessions = typeof ss == 'string' ? JSON.parse(ss) : ss
  let tokens = typeof t == 'string' ? JSON.parse(t) : t

  var mainAccount = accounts.filter(function(item){
    return item.data.card_number == cn;
  }).map(function(item){
    return item
  })[0]

  var filteredAccounts = accounts.filter(function(item){
    return item.data.card_number != cn;
  }).map(function(item){
    return item
  })

  var filteredSessions = sessions.filter(function(item){
    return item.card_number != cn;
  }).map(function(item){
    return item
  })

  let filteredTokens = tokens.filter(function(item){ 
    return item.card_number != cn
  }).map(function(item){ 
    return item 
  })

  //get the token for saving to first index of array
  let token = tokens.filter(function(item){ 
    return item.card_number == cn
  }).map(function(item){ 
    return item 
  })[0].token

  filteredAccounts.splice(0, 0, mainAccount)
  filteredSessions.splice(0, 0, {card_number: mainAccount.data.card_number, lcard_uuid: mainAccount.data.lcard_uuid, mobile_number: mainAccount.data.mobile})
  filteredTokens.splice(0, 0, {token: token, card_number: cn})
  
  await AsyncStorage.setItem(DBName + 'accounts', JSON.stringify(filteredAccounts))
  await AsyncStorage.setItem(DBName + 'session', JSON.stringify(filteredSessions))
  await AsyncStorage.setItem(DBName + 'token', JSON.stringify(filteredTokens))
  return true
}

export const setLogin = async () => {
  await AsyncStorage.setItem(DBName + "isLogin", JSON.stringify({isLogin: true}))
}

export const logoutAccount = async (callback, catcher) => {
  try{
    await AsyncStorage.setItem(DBName + "enter_mpin", "false")
    callback()
  } catch(error) {
    catcher(error, 0)
  }
}

export const logout = async (callback, catcher) => {
  try{
    const tokens = await AsyncStorage.getItem(DBName + "token")
    const ss = await AsyncStorage.getItem(DBName + "session")
    const acts = await AsyncStorage.getItem(DBName + "accounts")
    let tk = typeof tokens == "string" ? JSON.parse(tokens) : tokens
    let sessions = typeof ss == 'string' ? JSON.parse(ss) : ss
    let accounts = typeof acts == 'string' ? JSON.parse(acts) : acts
    let token = tk[tk.length > 0 ? tk.length - 1 : tk.length]

    fetch(URL.logout, {
      method: 'POST',
      headers: {
        Accept: 'application/json',
        'Content-Type': 'application/json',
        Authorization: typeof token == 'string' && token?.includes("Bearer ") ? token : "Bearer " + token
      },
      body: {},
    }).then(response => response.json())
    .then(async (data) => {
      sessions.splice(sessions.length - 1, 1)
      tk.splice(tk.length - 1, 1)
      accounts.splice(accounts.length - 1, 1)
      await AsyncStorage.setItem(DBName + "session", JSON.stringify(sessions))
      await AsyncStorage.setItem(DBName + "token", JSON.stringify(tk))
      await AsyncStorage.setItem(DBName + "accounts", JSON.stringify(accounts))
      // await AsyncStorage.removeItem(DBName + "session")
      // await AsyncStorage.removeItem(DBName + "token")
      callback(data, tk.length)
    });

  }catch(error){
    await AsyncStorage.setItem(DBName + "session", JSON.stringify([]))
    await AsyncStorage.setItem(DBName + "token", JSON.stringify([]))
    await AsyncStorage.setItem(DBName + "accounts", JSON.stringify([]))
    callback(error, 0)
  }
}

export default {
  get,
  set,
  session,
  logout,
  logoutAccount,
  AddNotification,
  remove,
  login,
  accounts,
  removeAccount,
  profile,
  updateProfile,
  settoken,
  setsession,
  addsession,
  addaccount,
  reset,
  resetSwitchAccount,
  switchaccount
}