import axios from 'axios';
import * as log from 'loglevel';

import { notNullAndEmpty } from '../utils/helperFunctions';
import { MiniAppError, MiniAppErrorType } from '../model/miniAppError';

const BASE_MINIAPP_URL = '/request/https://stg.paypay-corp.co.jp/opa-mini-app/';
export const instance = axios.create({
  timeout: 30000,
  baseURL: BASE_MINIAPP_URL,
});

export const internalHeaders = (headers: any) => {
  const token = JSON.parse(localStorage.getItem('token') || '""');
  headers['Authorization'] = `Bearer ${notNullAndEmpty(token) ? token : ''}`;
  const authId = JSON.parse(localStorage.getItem('X-USER-AUTH-ID') || '""');
  headers['X-USER-AUTH-ID'] = notNullAndEmpty(authId) ? authId : '';
  headers['Client-UUID'] = '5A103761-EFEA-4407-BB74-94475EFC05E1';
  headers['Device-UUID'] = '0623CD89-9B4C-404E-8A80-53BFF1D9498F';
  headers['Content-Type'] = 'application/json';
  headers['Client-Type'] = 'MINIAPP';
  headers['Client-Version'] = '9.9.9';
  headers['Client-OS-Type'] = 'IOS';
  return headers;
};
const interceptor = (config: any) => {
  internalHeaders(config.headers);
  return config;
};

instance?.interceptors.request.use(interceptor, (error) => {
  log.error(`API/OPA / ${JSON.stringify(error)}`);
  return Promise.reject(error);
});

const BASE_BFF_URL = '/request/https://stg-app3.paypay-corp.co.jp/bff/v1/';
export const instanceBff = axios.create({
  timeout: 30000,
  baseURL: BASE_BFF_URL,
});

instanceBff?.interceptors.request.use(interceptor, (error) => {
  log.error(`API/BFF / ${JSON.stringify(error)}`);
  return Promise.reject(error);
});

export const get = (
  url: string,
  params: any,
  config = {},
  useBaseUrl: boolean = true
) => {
  return new Promise((resolve, reject) => {
    instance({
      method: 'get',
      url,
      params,
      ...config,
      baseURL: useBaseUrl ? BASE_MINIAPP_URL : '',
    })
      .then((response) => {
        resolve(response);
      })
      .catch((error) => {
        if (error.response?.status === 401) {
          reject(new MiniAppError(MiniAppErrorType.invalidHeader));
        } else {
          reject(error);
        }
      });
  });
};

export const post = (url: string, data: any, config = {}) => {
  return new Promise((resolve, reject) => {
    instance({
      method: 'post',
      url,
      data,
      ...config,
      baseURL: BASE_MINIAPP_URL,
    })
      .then((response) => {
        resolve(response);
      })
      .catch((error) => {
        if (error.response.status === 401) {
          reject(new MiniAppError(MiniAppErrorType.invalidHeader));
        } else {
          reject(error);
        }
      });
  });
};

export const patch = (url: string, data: any, config = {}) => {
  return new Promise((resolve, reject) => {
    instance({
      method: 'patch',
      url,
      data,
      ...config,
      baseURL: BASE_MINIAPP_URL,
    })
      .then((response) => {
        resolve(response);
      })
      .catch((error) => {
        if (error.response.status === 401) {
          reject(new MiniAppError(MiniAppErrorType.invalidHeader));
        } else {
          reject(error);
        }
      });
  });
};

export const getBff = (url: string, params: any, config = {}) => {
  return new Promise((resolve, reject) => {
    instanceBff({
      method: 'get',
      url,
      params,
      ...config,
    })
      .then((response) => {
        resolve(response);
      })
      .catch((error) => {
        if (error.response.status === 401) {
          reject(new MiniAppError(MiniAppErrorType.invalidHeader));
        } else {
          reject(error);
        }
      });
  });
};

export const postBff = (url: string, data: any, config = {}) => {
  return new Promise((resolve, reject) => {
    instanceBff({
      method: 'post',
      url,
      data,
      ...config,
    })
      .then((response) => {
        resolve(response);
      })
      .catch((error) => {
        if (error.response.status === 401) {
          reject(new MiniAppError(MiniAppErrorType.invalidHeader));
        } else {
          reject(error);
        }
      });
  });
};