export default function callApi (options) {
  if (typeof options === 'string') options = { url: options }
  options.headers = options.headers || {}

  options.url = API_URL + '/' + options.url

  // pagination
  if (options.page && options.itemsPerPage) {
    const to = (options.page || 1) * options.itemsPerPage - 1
    const from = to - options.itemsPerPage + 1
    // this.header['Range-Unit'] = 'items'
    options.headers['Range'] = `${from || 0}-${to || ''}`
  }

  // single
  if (options.single) {
    options.headers['Prefer'] = 'plurality=singular'
  }

  return axios(options)
  .then(res => {
    const contentRange = res.headers['content-range']
    const json = res.data
    if (json && Array.isArray(json) && contentRange) {
      const range = ContentRangeStructure.exec(contentRange)
      if (range) {
        // const start = parseInt(range[1])
        // const end = parseInt(range[2])
        const total = parseInt(range[3])
        return [json, total]
      }
    }
    return json
  })
}

const fetchCharge = (localCharge: CoinbaseCharge) => {
	/**
	 * Skip all pending charges that are not at least 3 minutes old
	 * because we know it will take longer than that for Coinbase to process
	 */
	if (!localCharge.code) return;
	const seconds = timeElapsedInSeconds(localCharge.created_at);
	if (seconds < 180) return;

	const config: AxiosRequestConfig = {
		url: `https://api.commerce.coinbase.com/charges/${localCharge.code}`,
		method: 'get',
		headers: {
			'X-CC-Api-Key': `${process.env.COINBASE_API_KEY}`,
			'X-CC-Version': '2018-03-22'
		}
	};

	axios(config)
		.then(async (response: any) => {
			await processTransaction(response.data.data as CoinbaseCharge, localCharge);
		})
		.catch(function (error) {
			console.log(error);
		});
};

 const response = yield call(() => {
   // tslint:disable-next-line:no-console
   return axios({
     method: 'get',
     url: '/api/animals'
   });
 });

export async function import_dashboard(url: string) : Promise<any> {
  let api_url = get_api_url(url)
  log.info(`Importing dashboard from ${api_url}...`)

  // TODO: this is duplicated from query.ts
  let axios_config : any = {
    url: api_url.toString(),
    method: 'get'
  }

  let auth = config.GRAPHITE_AUTH ? config.GRAPHITE_AUTH.trim() : ''
  if (auth) {
    let [username, password] = auth.split(':')
    axios_config.auth = {
      username: username,
      password: password
    }
    axios_config.withCredentials = true
  }

  return axios(axios_config)
    .then(response => translate(response.data.state))
    .then(dash => {
      return manager.client.dashboard_create(dash)
        .then(response => {
          return response
        })
        .catch(error => {
          manager.error(`Error creating dashboard. ${error}`)
        })
    })
}

export function pins(
  swlng: number,
  swlat: number,
  nelng: number,
  nelat: number,
  pinTypes: PIN_TYPE[] = [PIN_TYPE.stop]
): Promise<IPin[]> {
  const sw = utils.WGS84toWm(swlng, swlat);
  const ne = utils.WGS84toWm(nelng, nelat);

  let url = "https://www.dvb.de/apps/map/pins?showLines=true";
  pinTypes.forEach((type) => (url += `&pintypes=${type}`));
  const options: AxiosRequestConfig = {
    url,
    params: {
      swlng: sw[0],
      swlat: sw[1],
      nelng: ne[0],
      nelat: ne[1],
    },
    responseType: "text",
    timeout: 5000,
  };

  return axios(options)
    .then((response) => {
      return response.data || [];
    })
    .then((elements) => elements.map((elem: string) => utils.parsePin(elem)));
}

 (_, getState) =>
   getState().auth && axios({
     method: "post",
     url: API.current.accountResetPath,
     data: payload,
   })
     .then(() => alert(t("Account has been reset.")))
     .catch((err: UnsafeError) => toastErrors({ err }));

 return packages.map((obj: { name: string }) =>
   axios({
     baseURL: `${constants.API_URL}`,
     url: `/${encodeURIComponent(obj.name)}`,
     method: 'GET',
     validateStatus: (status: number) =>
       (status >= 200 && status < 300) || status === 404,
   })

export function monitor(
  stopID: string,
  offset = 0,
  amount = 0
): Promise<IMonitor[]> {
  const now = new Date();
  const time = new Date(now.getTime() + offset * 60 * 1000);

  const options: AxiosRequestConfig = {
    url: "https://webapi.vvo-online.de/dm",
    params: {
      format: "json",
      stopid: stopID,
      time: time.toISOString(),
      isarrival: false,
      limit: amount,
      shorttermchanges: true,
      mentzonly: false,
    },
    timeout: 5000,
  };

  return axios(options)
    .then((response) => {
      // check status of response
      utils.checkStatus(response.data);

      if (response.data.Departures) {
        return response.data.Departures.map((d: any) => {
          const arrivalTime = utils.parseDate(
            d.RealTime ? d.RealTime : d.ScheduledTime
          );
          const scheduledTime = utils.parseDate(d.ScheduledTime);

          return {
            arrivalTime,
            scheduledTime,
            id: d.Id,
            line: d.LineName,
            direction: d.Direction,
            platform: utils.parsePlatform(d.Platform),
            arrivalTimeRelative: dateDifference(now, arrivalTime),
            scheduledTimeRelative: dateDifference(now, scheduledTime),
            delayTime: dateDifference(scheduledTime, arrivalTime),
            state: d.State ? d.State : "Unknown",
            mode: utils.parseMode(d.Mot),
            diva: utils.parseDiva(d.Diva),
          };
        });
      }

      return [];
    })
    .catch(utils.convertError);
}

const callApi = async (options: AxiosRequestConfig) => {
  try {
    const response = await axios(options);
    return response.data.data;
  } catch (e) {
    if (e.response && e.response.data && e.response.data.errors) {
      e.message = values(e.response.data.errors)[0];
    }
    throw e;
  }
};

async function pointFinder(
  name: string,
  stopsOnly: boolean,
  assignedStops: boolean
): Promise<IPoint[]> {
  if (typeof name !== "string") {
    throw utils.constructError("ValidationError", "query has to be a string");
  }

  const stopName = name.trim();

  const options: AxiosRequestConfig = {
    url: "https://webapi.vvo-online.de/tr/pointfinder",
    params: {
      format: "json",
      stopsOnly,
      assignedStops,
      limit: 0,
      query: stopName,
      dvb: true,
    },
    timeout: 5000,
  };

  return axios(options)
    .then((response) => {
      // check status of response
      utils.checkStatus(response.data);

      if (response.data.Points) {
        return response.data.Points.map((p: string) => {
          const poi = p.split("|");

          const city = poi[2] === "" ? "Dresden" : poi[2];
          const idAndType = utils.parsePoiID(poi[0]);
          const coords = utils.WmOrGK4toWGS84(poi[5], poi[4]);

          if (coords) {
            const point: IPoint = {
              city,
              coords,
              name: poi[3].replace(/'/g, ""),
              id: idAndType.id,
              type: idAndType.type,
            };
            return point;
          }
        }).filter((p: IPoint) => p && p.name);
      }

      return [];
    })
    .catch(utils.convertError);
}