import { getInfo } from "../../api/login";
import { stockLogList, stockStatistics, storageList } from "../../api/stock";
import httpClient from "../../utils/request";

// pages/stock/stock.ts
Page({
  /**
   * 页面的初始数据
   */
  data: {
    permissions: [],
    authToken: undefined,
    stockType: 0, // 库存类型
    // 统计数据
    statisticsData: {
      total: {
        label: "产品总数",
        value: 0,
      },
      in: {
        label: "当月入库",
        value: 0,
      },
      out: {
        label: "当月出库",
        value: 0,
      },
    },
    inStockQuery: {
      pageNum: 1,
      pageSize: 10,
    },
    outStockQuery: {
      pageNum: 1,
      pageSize: 10,
    },
    storageQuery: {
      pageNum: 1,
      pageSize: 10,
    },
    storageList: [], // 库存列表
    inStockList: [], // 入库列表
    outStockList: [], // 出库列表
    storageLoading: false,
    inStockLoading: false,
    outStockLoading: false,
    storageCompleted: false,
    inStockCompleted: false,
    outStockCompleted: false,
  },
  onTabsChange(e: any) {
    const { value: stockType } = e.detail;
    this.setData({
      stockType,
    });
    if (stockType > 0) {
      if (
        (stockType == 1 && this.data.inStockList.length == 0) ||
        (stockType == 2 && this.data.outStockList.length == 0)
      ) {
        this.getStockIOList();
      }
    } else {
      if (this.data.storageList.length === 0) {
        this.getStorageList();
      }
    }
  },

  async loadData() {
    const authToken = getApp().globalData.authToken;
    this.setData({
      authToken,
    });
    if (!authToken) return;
    const { stockType } = this.data;
    if (stockType == 0) {
      await this.getStorageList();
    } else {
      await this.getStockIOList();
    }
    await this.loadStatisticData();
  },

  /**
   * 加载出入库日志列表
   */
  async getStockIOList() {
    const { inStockQuery, outStockQuery, stockType } = this.data;
    let query;
    if (stockType == 1) {
      this.setData({
        inStockLoading: true,
      });
      query = inStockQuery;
    } else if (stockType == 2) {
      this.setData({
        outStockLoading: true,
      });
      query = outStockQuery;
    } else {
      return;
    }
    try {
      const resp: any = await stockLogList({
        type: stockType,
        pageNum: query.pageNum,
        pageSize: query.pageSize,
      });
      let completed = false;
      if (stockType == 1) {
        if (
          Math.ceil(resp.total / inStockQuery.pageSize) == inStockQuery.pageNum
        ) {
          completed = true;
        }

        this.setData({
          inStockCompleted: completed,
          // @ts-ignore
          inStockList: [
            ...this.data.inStockList,
            ...resp.rows.map((el: any) => ({
              ...el,
              provePic:
                el.provePic?.split(",").map((img: string) => {
                  if (img.startsWith("http://") || img.startsWith("https://")) {
                    return img;
                  } else {
                    return `${httpClient.baseUrl}${img}`;
                  }
                }) ?? [],
            })),
          ],
        });
        if (!completed) {
          this.setData({
            ["inStockQuery.pageNum"]: inStockQuery.pageNum + 1,
          });
        }
      } else if (stockType == 2) {
        if (
          Math.ceil(resp.total / outStockQuery.pageSize) ==
          outStockQuery.pageNum
        ) {
          completed = true;
        }
        this.setData({
          outStockCompleted: completed,
          // @ts-ignore
          outStockList: [
            ...this.data.outStockList,
            ...resp.rows.map((el: any) => ({
              ...el,
              provePic:
                el.provePic?.split(",").map((img: string) => {
                  if (img.startsWith("http://") || img.startsWith("https://")) {
                    return img;
                  } else {
                    return `${httpClient.baseUrl}${img}`;
                  }
                }) ?? [],
            })),
          ],
        });
        if (!completed) {
          this.setData({
            ["outStockQuery.pageNum"]: outStockQuery.pageNum + 1,
          });
        }
      }
    } catch (error) {
      console.log(error);
    }
    if (this.data.stockType == 1) {
      this.setData({
        inStockLoading: false,
      });
    } else if (this.data.stockType == 2) {
      this.setData({
        outStockLoading: false,
      });
    }
  },
  /**
   * 获取库存列表
   */
  async getStorageList() {
    this.setData({
      storageLoading: false,
    });
    const { storageQuery } = this.data;
    try {
      const resp: any = await storageList(storageQuery);

      let completed = false;
      if (
        Math.ceil(resp.total / storageQuery.pageSize) == storageQuery.pageNum
      ) {
        completed = true;
      }
      this.setData({
        // @ts-ignore
        storageList: [...this.data.storageList, ...resp.rows],
        storageCompleted: completed,
      });
      if (!completed) {
        this.setData({
          [`storageQuery.pageNum`]: storageQuery.pageNum + 1,
        });
      }
    } catch (error) {}
    this.setData({
      storageLoading: false,
    });
  },
  /**
   * 获取统计数据列表
   */
  async loadStatisticData() {
    const resp: any = await stockStatistics();
    this.setData({
      ["statisticsData.in.value"]: resp.data.in,
      ["statisticsData.out.value"]: resp.data.out,
      ["statisticsData.total.value"]: resp.data.total,
    });
  },
  /**
   * 触底时，加载更多库存列表
   */
  loadMoreStorage() {
    console.log("库存到底了");
    const { storageLoading, storageCompleted } = this.data;
    if (storageLoading || storageCompleted) {
      return;
    }
    this.getStorageList();
  },
  /**
   * 触底时，加载更多入库列表
   */
  loadMoreInStock() {
    const { inStockLoading, inStockCompleted } = this.data;
    console.log(inStockLoading, inStockCompleted);

    if (inStockLoading || inStockCompleted) {
      return;
    }
    this.getStockIOList();
  },
  /**
   * 触底时，加载更多出库列表
   */
  loadMoreOutStock() {
    const { outStockLoading, outStockCompleted } = this.data;
    if (outStockLoading || outStockCompleted) {
      return;
    }
    this.getStockIOList();
  },
  handleAddStock() {
    const { stockType } = this.data;
    wx.navigateTo({
      url: `/pages/add-stock/add-stock?type=${stockType}`,
    });
  },
  loadUserInfo() {
    const permissions = getApp().globalData.permissions;

    if (permissions) {
      this.setData({
        permissions,
      });
    } else {
      const token = getApp().globalData.authToken;
      getInfo(token).then((resp: any) => {
        this.setData({
          permissions: resp.permissions,
        });
        getApp().globalData.permissions = resp.permissions;
      });
    }
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad() {
    this.loadData();
    this.loadUserInfo();
  },
  /**
   * 刷新此页面
   */
  async handleRefresh() {
    this.setData({
      ["inStockQuery.pageNum"]: 1,
      ["outStockQuery.pageNum"]: 1,
      ["storageQuery.pageNum"]: 1,
      storageLoading: false,
      inStockLoading: false,
      outStockLoading: false,
      storageCompleted: false,
      inStockCompleted: false,
      outStockCompleted: false,
      inStockList: [],
      outStockList: [],
      storageList: [],
    });
    await this.loadData();
    wx.stopPullDownRefresh();
  },
  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {},

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {},

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {},

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {},

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    this.handleRefresh();
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
    const { stockType } = this.data;
    if (stockType == 0) {
      this.loadMoreStorage();
    } else if (stockType == 1) {
      this.loadMoreInStock();
    } else if (stockType == 2) {
      this.loadMoreOutStock();
    }
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {},
});