import qs from 'qs';
import axios, {AxiosResponse} from 'axios';
import {t} from 'i18next';
import {Alert} from 'react-native';
const CONTENT_TYPE_URL_ENCODED =
  'application/x-www-form-urlencoded;charset=UTF-8';
const defaultConfig = {
  // timeout: 30000, //100000,
  headers: {
    'content-type': CONTENT_TYPE_URL_ENCODED,
  },
  validateStatus: function (status) {
    return status < 600;
  },
};

const instance = axios.create(defaultConfig);

// Sends a GET request to the specified URL with the specified options
// async function get(url: string, params: any, {signal}) {
//   return sendRequest('get', url, params, {signal});
// }
async function get(url: string, params: any) {
  return sendRequest('get', url, params);
}

// Sends a POST request to the specified URL with the specified params and options
async function post(url: any, params: any, options: any = {}) {
  // Set the default value for the options.headers object
  options.headers = options.headers || {};
  console.log('Header is ===================>', options);
  // Set the content-type header to the specified value, or the default value if not specified
  options.headers['content-type'] =
    options.headers['content-type'] || CONTENT_TYPE_URL_ENCODED;
  return sendRequest('post', url, params, {...options});
}

// Sends a PATCH request to the specified URL with the specified params
async function patch(url: any, params: any) {
  return sendRequest('patch', url, params);
}

// Sends a PUT request to the specified URL with the specified params
async function put(url: any, params: any) {
  sendRequest('put', url, params);
}

// Sends a DELETE request to the specified URL
async function Delete(url: any) {
  return sendRequest('delete', url);
}

// Sends a request to the specified URL using the specified method and options
async function sendRequest(
  method: string,
  url: any,
  params: any = {},
  options: any = {},
) {
  // Create a cancel token and a timer to cancel the request if it takes too long
  const source = axios.CancelToken.source();
  // const timer = setTimeout(() => {
  //   source.cancel();
  // }, 60 * 1000);
  // Set the cancel token as an option for the request
  options.cancelToken = source.token;
  // Send the request using the specified method, URL, params, and options

  const response = await instance[method](url, params, options);
  // Clear the timer
  //clearTimeout(timer);
  // Return the response

  console.log('response umang is', response);
  return response;
}

export function errorInterceptor(): string | void {
  instance.interceptors.response.use(undefined, error => {
    const {response} = error;

    if (!response) {
      // network error
      console.error(error);
      return;
    }

    if ([401, 403].includes(response.status)) {
      // auto logout if 401 or 403 response returned from api
      // accountService.logout();
    }

    // const errorMessage = response.data;
    // console.log('errorMessage', errorMessage)
    return response;
  });
}

/**
 * @param {object} data json object that contains key value for request to server
 * This will take data as JSON Object and return in Form of json Object and encode the url
 * @returns {object} This function will return object that hold url encoded data
 */
export const getFormDataObjForUrlEn = data => {
  const formData = Object.keys(data)
    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
    .join('&');
  return formData;
};

const methodMap = {
  GET: get,
  POST: post,
  PATCH: patch,
  PUT: put,
  DELETE: Delete,
};

export async function send(params: {
  method: string;
  url: string;
  obj?: any;
  isRawData?: boolean;
  contentType?: any;
  signal?: any;
}): Promise<any> {
  // Validate the input params
  validateParams(params);

  // Get the appropriate function for the specified HTTP method
  const func = getMethodFunc(params.method);

  // Send the request and handle the response/error
  return request(func, params);
}

function validateParams(params: any) {
  if (!params || typeof params !== 'object') {
    throw new Error('params is undefined or not an object');
  }
}

function getMethodFunc(method: string) {
  const func = methodMap[method];
  if (!func) {
    throw new Error(`Invalid HTTP method: ${method}`);
  }
  return func;
}

async function request(func: any, params: any) {
  console.log('request =============>', params.contentType);
  try {
    let result;
    if (params.method === 'GET') {
      let obj = params.obj;
      console.log('obj param is', params);
      if (!params.isRawData) {
        // obj = qs.stringify(obj);
        // console.log('obj is', obj);

        result = await func(params.url, obj, {signal: params.signal});
        console.log('bbbbb', result);
      } else {
        result = await func(params.url, {signal: params.signal});
      }
    } else {
      let obj = params.obj;
      if (params.method === 'POST' && !params.isRawData) {
        obj = qs.stringify(obj);
      }
      const options = {
        headers: {
          'content-type': params.contentType || '',
        },
      };
      result = await func(params.url, obj, options);
    }
    return result;
  } catch (error) {
    console.log('uuu error is', error);
    //const err = errorInterceptor();
    throw error;
  }
}

export enum RW3ResponseError {
  RW3Success = 0,
  RW3Error409 = 1,
  RW3Error401 = 2,
  RW3ErrorResponseMessage = 3,
}

export function getResponseStatus(response: any): RW3ResponseError {
  if ([200].includes(response.status)) {
    return RW3ResponseError.RW3Success;
  } else {
    if (response.status === 409) {
      return RW3ResponseError.RW3Error409;
    } else if (response.status === 401) {
      Alert.alert(
        `${t('INVALID_CREDENTIAL_TITLE')}`,
        response.data.LoginErrorMessage,
        [{text: `${t('ALERT_DISMISS')}`, style: 'cancel'}],
      );
      return RW3ResponseError.RW3Error401;
    } else {
      if ('LoginErrorMessage' in response.data) {
        Alert.alert('', response.data.LoginErrorMessage, [
          {text: `${t('ALERT_DISMISS')}`, style: 'cancel'},
        ]);
      } else {
        Alert.alert('', response.data.Message, [
          {text: `${t('ALERT_DISMISS')}`, style: 'cancel'},
        ]);
      }
      return RW3ResponseError.RW3ErrorResponseMessage;
    }
  }
}