/* eslint-disable class-methods-use-this, no-underscore-dangle, arrow-parens, no-return-assign, no-sequences */
import axios from 'axios'
import cookie from 'js-cookie'

import { endpointApiUser } from '../../core/constants'


const user = axios.create({
  baseURL: `${endpointApiUser}`,
  headers: {
    'Content-Type': 'application/json',
  },
  transformRequest: [(postData = {}, headers) => {
    // eslint-disable-next-line no-param-reassign
    return JSON.stringify(postData)
  }],
  timeout: 3000,
})


type ResponseUserBalance = {
  balance: number,
  currency: string,
  taxDiscount: number,
  taxRate: number,
};


class User {
  constructor() {
    this.user = null
    this.token = cookie.get('token') || null
    this.tokenttl = parseInt(cookie.get('tokenttl'), 10) || 0
  }

  _normalize = (responseUser) => ({
    email: responseUser.email,
    firstName: responseUser.firstName,
    lastName: responseUser.lastName,
    login: responseUser.username,
    session: responseUser.token,
    cps: responseUser.authorized,
    phone: responseUser.phone,
    bonuses: [],
  })

  _normalizeBalance = (balance = {}) => ({
    balance: balance.balance || 0,
    currency: balance.currency || '',
    currencyId: null,
    country: null,
    messages: null,
    taxDiscount: balance.taxDiscount,
    taxRate: balance.taxDiscount,
  })

  _handleToken(d) {
    this.token = `Bearer ${d.token}`
    this.tokenttl = +new Date() + d.ttl
    cookie.set('token', this.token, { expires: this.tokenttl })
    cookie.set('tokenttl', this.tokenttl, { expires: this.tokenttl })
    this.user = this._normalize(d)

    return this.user
  }

  _handleTokenError = (error) => {
    if (!error || !error.response) return Promise.reject(error)

    const { data } = error.response
    const { invalidParameters } = data


    // return Promise.reject({ validationErrors, ...data })

    return Promise.reject({
      messages: invalidParameters.reduce((text, it) => `${text}\n${it.name}: ${it.message}`, '')
    })
  }

  signIn = (login, password) => user.post('/user/login', { login, password })
    .then((d) => this._handleToken(d.data))
    .catch((error) => this._handleTokenError(error))

  signUp = (phone, email, promo, username, password) => user.post('/user/register', { phone, email, username, password })
    .then((d) => this._handleToken(d.data))
    .catch((error) => this._handleTokenError(error))

  getUser = async () => {
    try {
      const userData = await this._checkTokenttl()
      const balance = await this._getBalance()

      this.user = { ...userData, ...this._normalizeBalance(balance) }

      return this.user
    }
    catch (error) {
      return Promise.reject(error)
    }
  }

  signOut = () => {
    cookie.remove('token')
    this.token = null
    user.get('/user/logout', { headers: { Authorization: this.token }})
      .then(
        (data) => console.log(data),
        (error) => console.log(error),
      )
    return null
  }

  loadStakeHistory = page => user.get(`history/bet?page=${page}&pageSize=10`, { headers: { Authorization: this.token}})
    .then(data => data.data)
    .catch(error => this._historyErrorConstructor(error))

  loadHistory = page => user.get(`history/payment?page=${page}&pageSize=10`, { headers: { Authorization: this.token}})
    .then(data => data.data)
    .catch(error => this._historyErrorConstructor(error))

  _historyErrorConstructor = (error) => {
      console.log(error)
      if (error && error.response) {
        const { data } = error.response
        const { invalidParameters } = data
        const validationErrors = {}

        if (invalidParameters) {
          invalidParameters.map((field) => {
            validationErrors[field.name] = field.message
            return field
          })
        }
        return Promise.reject({ validationErrors, ...data })
      }
    }

  _getBalance(): Promise<ResponseUserBalance> {
    return user.get('account/info', { headers: { Authorization: this.token }})
      .then((d) => d.data.accounts[0])
  }

  _checkTokenttl() {
    if (this.tokenttl) {
      const leftTimeInMunites = (this.tokenttl - (new Date()).valueOf()) / 1000 / 60

      if (leftTimeInMunites < 0) {
        return Promise.reject(new Error('время истекло, нужно перелогиниться'))
      }

      // если осталось меньше 10 минут до истечения срока токена
      // или если информация о пользователе пуста
      if (leftTimeInMunites < 10 || !this.user) {
        return this._updateToken()
      }
      return Promise.resolve(this.user)
    }
    return Promise.reject(new Error('время истекло, нужно перелогиниться'))
  }

  _updateToken = () => user.get('/user/token', { headers: { Authorization: this.token }})
    .then((d) => this._handleToken(d.data))
    .catch((error) => this._handleTokenError(error))

  /*
  confirmationRequest = () => user.get('/user/phone/confirm')
    .then(
      (data) => data,
      (error) => console.log(error),
    )

  confirmation = (code) => user.post('/user/phone/confirm', { code })
    .then(
      (data) => data,
      (error) => console.log(error),
    )

  updateUser() {
    return user.get('/user')
      .then(
        (data) => {
          this.userInfo = this.userInfoConstructor(data.data)

          return this.userInfo
        },
        (error) => console.log(error),
      )
  }
  */
}

const userApi = new User()

export { userApi }