// api.js
import req from './reqMethod.js';   // 封装接口方法

const baseUrl = 'https://www.域名1.com';    // 配置默认域名
const reqMethod = function () {
  let arg = Array.from(arguments);
  arg.splice(3, 0, baseUrl);
  return req.apply(null, arg);
};

export const getBrandmenus = params => reqMethod('GET', `/api/path`, params);
export const editNickname = params => reqMethod('GET', '/api/path', params);
export const addFavouriteCar = params => reqMethod('GET', '/api/path', params);
export const delFavouriteCar = params => reqMethod('GET', '/api/path', params);

// app.ux
const injectRef = Object.getPrototypeOf(global) || global;
import * as api from './api.js';
injectRef.API = api;

export default {
  async getDataList() {
    try {
      const res = await API.getBrandmenus({
        sessionid: deviceInfo.deviceId
      });
      this.list = res.result.map(item => {
        item.date = UTILS.Formate(item.date, 'YYYY-MM-DD');
        return item;
      });
    } catch (error) {
      console.log(error);
    }
  }
}

// reqMethod.js
import fetch from '@system.fetch';
import prompt from '@system.prompt';

function reqMethod(method, url, params = {}, baseUrl, stateDetection = true, showPrompt = true) {
  fixXiaomiParamsBug(params);
  url = /^http/.test(url) ? url : baseUrl + url;   // 扩展支持多域名配置
  params = sign(params);
  return request(method, url, params, stateDetection, showPrompt);
}

function request(method, url, params, stateDetection = true, showPrompt = true) {
  return new Promise((resolve, reject) => {
    fetch.fetch({
      url: url,
      data: params,
      method: method,
      success: (res) => {
        try {
          if (res.code !== 200) {
            prompt.showToast({
              message: '网络错误'
            });
            reject(res);
            return;
          }

          const data = JSON.parse(res.data);
          if (data.returncode === 0) {
            resolve(data);
            return;
          } else {
            if (!stateDetection) {
              resolve(data);
              return;
            }
            if (showPrompt) {
              prompt.showToast({
                message: data.message
              });
            }
            reject(res);
          }
        } catch (error) {
          reject(res);
        }
      },
      fail: function (res, code) {
        prompt.showToast({
          message: '网络错误'
        });
        reject(res);
      }
    });
  });
}

// 小米 1030 版本bug 小数点后超过3位的数字会被截取，解决方法转换成字符串传递
function fixXiaomiParamsBug(params) {
  if (typeof params === 'object') {
    for (let key in params) {
      if (typeof params[key] === 'number') {
        const x = String(params[key]).indexOf('.') + 1;   //小数点的位置
        const y = String(params[key]).length - x;  //小数的位数
        if (y > 3) params[key] = String(params[key]);
      }
    }
  }
}

function sign(obj) {
  // 加密签名方法
}

export default reqMethod;

// app.ux
const injectRef = Object.getPrototypeOf(global) || global;  // 获取全局对象

import * as Utils from './utils/index.js';  // 引入公共方法
const { api } = Utils;
injectRef.UTILS = Utils;  // 挂载到全局对象
injectRef.API = api;      // API 方法是对 fetch 方法的封装含有 sign 和 token

// index.ux
export default {
  async getDataList() {
    try {
      const res = await API.getBrandmenus({ // 直接调用全局 API 方法获取接口数据。
        sessionid: deviceInfo.deviceId
      });
      this.list = res.result.map(item => {
        item.date = UTILS.Formate(item.date, 'YYYY-MM-DD');   // 调用全局公共方法 UTILS 下的 Formate 格式化时间
        return item;
      });
    } catch (error) {
      console.log(error);
    }
  }
}

geolocation.getLocation({
  success: function(data) {
    console.log(
      `handling success: longitude = ${data.longitude}, latitude = ${
        data.latitude
      }`
    )
  },
  fail: function(data, code) {
    console.log(`handling fail, code = ${code}`)
  }
})

// promiseAPI.js
import storage from '@system.storage';
import device from '@system.device';
import network from '@system.network';
import geolocation from '@system.geolocation';

const promiseFactory = (pointer, params = {}) => {
  return new Promise((resolve, reject) => {
    params = Object.assign({
      success: (data) => { resolve(data); },
      fail: (err, code) => { reject(err, code) }
    }, params);
    pointer(params);
  });
};

// 获取设备信息。
export const getDeviceInfo = () => promiseFactory(device.getInfo);
// 获取设备Id。
export const getDeviceId = () => promiseFactory(device.getId, { type: ["device", "mac"] });
// 读取存储内容。
export const getStorage = (key) => promiseFactory(storage.get, { key });
// 修改存储内容。
export const setStorage = (key, value) => promiseFactory(storage.set, { key, value });
// 清空存储内容。
export const clearStorage = (key, value) => promiseFactory(storage.clear);
// 获取网络类型。
export const getNetworkType = () => promiseFactory(network.getType);
// 获取地理位置。
export const getLocation = () => promiseFactory(geolocation.getLocation, { timeout: 3000 });

// index.ux
import * as promiseApi from './promiseAPI.js';

const getDeviceIdMethods = async () => {
  try {
    const data = await promiseApi.getDeviceId();
    systemInfo = Object.assign({}, systemInfo, {
      'deviceId': data.device,
      'IMEI': data.device,
      'macAddress': data.mac
    });
  } catch (error) {
    console.log('获取设备ID失败');
  }
};

onShow() {
  this.watchCurrentIndexChange(this.currentindex, null);
},
onHide() {
  this.watchCurrentIndexChange(null, this.currentindex);
}

onShow() {
  PV_TRACK.startTime('页面标识', this.auto_open_from);
}
onHide() {
  PV_TRACK.endTime('页面标识', this.auto_open_from);
}

onShow() {
  PV_TRACK.page_show(this, { uid: '业务扩展字段' });
}
onHide() {
  PV_TRACK.page_show(this, { uid: '业务扩展字段' });
}

PV_TRACK.click(page, event);

const { PV, getDeviceData } = Utils;
const pv = new PV();
injectRef.PV_TRACK = pv;
let deviceData = null;
let deviceCompleteArray = [];

export default {
  onCreate() {
    // 快应用启动统计
    pv.send({
      cate: 'clt',
      event: 'kuai_app_launch_clt'
    });
    getDeviceData().then(res => {
      deviceData = res;
      console.log('################ 获取设备信息 #################');
      pv.setInfo(res);
      while (deviceCompleteArray.length) {
        const resolve = deviceCompleteArray.shift();
        resolve(res);
      }
    }).catch(err => {
      console.log(err);
    });
  },
  getDeviceInfo() {
    return new Promise((resolve, reject) => {
      if (!deviceData) {
        deviceCompleteArray.push(resolve);
      } else {
        resolve(deviceData);
      }
    });
  }
};

async onInit() {
  try {
    await this.$app.$def.getDeviceInfo();
    await this.getList();
  } catch (error) {
    console.log(error);
  }
}

while (deviceCompleteArray.length) {
  const resolve = deviceCompleteArray.shift();
  resolve(res);
}