const util = require("./components/util"); // 引入封装过的加载提示
import {
  loginInfo
} from "../../../../../../assets/js/login";
const app = getApp();
Component({
  properties: {
    treeList: {
      type: Array,
      value: [],
    },
    learnList: {
      type: Array,
      value: [],
    },
    bookInfo: {
      type: Object,
      value: {},
    },
    buyIds: {
      type: Array,
      value: [],
    },
    tab: {
      type: String,
      value: "",
    },
    applyState: {
      type: String,
      value: "",
    },
    openIds: {
      type: Array,
      value: [],
    },
    isShowCheck: {
      type: Boolean,
      value: false,
    },
    paymentPage: {
      type: Boolean,
      value: false,
    },
    superior: {
      type: Boolean,
      value: false,
    },
    checkAllState: {
      type: Boolean,
    },
    deadline: {
      type: String,
    },
    cloundMenuIsBuy: {
      type: Boolean
    }
  },
  data: {
    activeValues: [1, 2],
    webpageSrc: "",
    cloudShoppingCart: [],
    shoppingCart: true,
    stop: false,
    cart: true,
    canExecute: true,
    purchaseList: []
  },
  ready() {},

  onLoad() {},
  observers: {
    treeList: function (newValue) {
      const list = [];
      let checked = "";
      this.properties.treeList.forEach((item) => {
        if (item.children && item.children.length > 0) {
          list.push(...this.flattenTree([item]));
        }
      });
      const flag = list.findIndex((item) => item.checked == true);
    },
  },

  methods: {
    handleList(tree) {
      for (let index = 0; index < tree.length; index++) {
        const item = tree[index];
        if (item.sysType == "CmsItem" && !item.checked) {}
        if (item.children && item.children.length > 0) {
          this.handleList(item.children);
        }
      }
    },
    // 遍历树结构转换为数组方法
    handleTreeData(array) {
      const flattenedArray = [];
      array.forEach((node) => {
        // 将当前节点添加到展开的数组中
        flattenedArray.push(node);
        // 递归处理子节点
        if (node.children && node.children.length > 0) {
          const childrenArray = this.handleTreeData(node.children);
          flattenedArray.push(...childrenArray);
        }
      });
      return flattenedArray;
    },
    // 节点展开
    handleChange(e) {
      this.setData({
        openIds: e.detail.value,
      });
    },
    handleCheck(data) {
      for (let index = 0; index < data.length; index++) {
        const element = data[index];
        element.checked = true;
        if (element.childrenCount && element.type == "productFolder") {
          handleCheck(element.children);
        }
      }
    },
    downloadTeach(e) {
      const value = e.currentTarget.dataset.value;
      var myEventDetail = {
        value,
      }; // detail对象，提供给事件监听函数
      var myEventOption = {
        bubbles: true,
        composed: true,
      }; // 触发事件的选项
      this.triggerEvent("downloadTeach", myEventDetail, myEventOption);
    },
    // 判断资源是否购买
    resourceIsBuy(data) {
      if (data.saleMethod && data.saleMethod.length) {
        const saleData = data.saleMethod.find((item) => item.SaleType == 'Normal')
        if (saleData.State == 'Disable') return false
        const isSHow = this.properties.buyIds.some(
          (item) => item == saleData.Id
        );
        // 已经购买
        if (isShow) return false
        // 未购买，查看销售方式是否过期
        if (!isShow) {
          const flag = new Date(saleData.EndDate).getTime() >= new Date().getTime() &&
            new Date(saleData.BeginDate).getTime() <= new Date().getTime()
          if (flag) {
            // 为过期 ，需要购买
            return true
          } else {
            // 已过期 无需购买
            return false
          }
        }
      } else {
        return false;
      }
    },
    // 跳转音视频播放器
    goPlayer(e) {
      // 检查登录状态
      const token = wx.getStorageSync(app.config.tokenKey);
      if (!token) return false
      const item = e.currentTarget.dataset.item;
      const parent = e.currentTarget.dataset.parent;
      const parentProductLinkPath = parent ?
        parent.productLinkPath :
        wx.getStorageSync("teachResourcesPath");
      const parentName = parent ? parent.name : "教学资源";
      // 资源购买页面(只展示未购买资源) 点击不跳转
      if (this.properties.isShowCheck) return false;
      if (item.selectType == "webpage") {
        // 网页类型跳转到网址复制页，因为url传参不能传 带参数的网络地址，所以此处要把网络地址里的传参摘出来，放到url里
        let urlData = ''
        const flags = item.jsek_link.indexOf("?")
        if (flags > -1) {
          urlData = item.jsek_link.slice(flags + 1, item.jsek_link.length)
        }
        url = '/packageBookService/pages/bookServices/linkPage/index'
        return wx.navigateTo({
          url: urlData ? url + `?path=${item.jsek_link.slice(0,flags)}` + '&' + urlData : url + `?path=${item.jsek_link}`
        })
      }
      if (!item.file && !item.freeFile && !item.protectedFile) {
        return wx.showToast({
          icon: 'error',
          title: '暂无资源',
        })
      }
      if (item.selectType == 'zip') {
        if (this.properties.applyState == 'Normal') {
          return wx.showToast({
            icon: 'error',
            title: '请前往PC端下载',
          })
        } else {
          return wx.showToast({
            icon: 'error',
            title: '请先申请下载',
          })
        }
      }
      if (this.properties.tab == "jsek_teachingResources" && (item.file || item.freeFile)) {
        let file = item.fileMap[item.file] ? item.fileMap[item.file] : item.fileMap[item.freeFile]
        if (file && file.protectType !== "Public") {
          return wx.showToast({
            icon: "error",
            title: "资源不可用，请联系管理员",
          });
        }
      }
      if (this.properties.tab == "jsek_cloudLearning") {
        // 判断父级或自身是否购买
        var myEventOption = {
          bubbles: true,
          composed: true,
        };
        // 出发判断云学习是否购买判断
        this.triggerEvent("getCloundIsBuy", {}, myEventOption)
        if (!this.properties.cloundMenuIsBuy) {
          // 云学习未购买，查找以购买的目录和资源本身
          const learn = this.handleTreeData(this.properties.treeList).filter(
            (citem) => citem.saleMethod &&
            citem.saleMethod.find((ditem) => ditem.SaleType == 'Normal') &&
            new Date(citem.saleMethod.find((ditem) => ditem.SaleType == 'Normal').EndDate).getTime() >= new Date().getTime() &&
            new Date(citem.saleMethod.find((ditem) => ditem.SaleType == 'Normal').BeginDate).getTime() <= new Date().getTime() &&
            item.productLinkPath.includes(citem.productLinkPath)
          )
          // 资源和父级目录都无销售方式
          // if (!learn.length) return wx.showToast({
          //   icon: 'error',
          //   title: '暂未开售',
          // })
          const buyList = learn.filter((citem) => this.properties.buyIds.includes(citem.saleMethod.find((ditem) => ditem.SaleType == 'Normal').Id))
          // 资源和本身都未购买
          if (!buyList.length) {
            const itemSaleMethod = item.saleMethod && item.saleMethod.length ? item.saleMethod.find(citem => citem.SaleType == 'Normal') : undefined
            return wx.showToast({
              icon: 'error',
              title: itemSaleMethod && itemSaleMethod.Price == 0 ? '请先领取资源' : '请先购买资源',
            })
          }
        }
      }
      let url;
      if (item.selectType == "video" || item.learnSelectType == "video") {
        url = "/packageDomain/pages/resourceDetails/myVideo/index";
      }
      if (
        item.selectType == "audio" ||
        item.learnSelectType == "audio"
      ) {
        url = "/packageDomain/pages/resourceDetails/myAudio/index";
      }
      if (item.selectType == "picture") {
        url = "/packageDomain/pages/resourceDetails/document/index";
      }
      wx.navigateTo({
        url: `${url}?productLinkPath=${item.productLinkPath}&parentProductLinkPath=${parentProductLinkPath}&parentName=${parentName}&activeId=${item.id}&bookId=${this.properties.bookInfo.id}&bookName=${this.properties.bookInfo.name}&cmsId=${this.properties.bookInfo.rootCmsItemId}&formPath=${this.properties.tab}&applyState=${this.properties.applyState}&deadline=${this.properties.deadline}`,
      });
    },

    // 拿到所有项
    getAllChildren(id) {
      let result = [];

      function findChildren(item) {
        if (item.id === id) {
          if (item.children && item.children.length > 0) {
            item.children.forEach((child) => {
              findChildren(child);
            });
          }
        } else {
          if (item.children && item.children.length > 0) {
            item.children.forEach((child) => {
              findChildren(child);
            });
          }
        }
        if (item.children && item.children.length > 0) {
          result.push(...item.children);
        }
      }
      this.properties.treeList.forEach((item) => {
        findChildren(item);
      });
      return result;
    },
    // 拿到当前项子项
    flattenTree(tree) {
      let result = [];

      function flatten(node) {
        result.push(node);
        if (node.children && node.children.length > 0) {
          node.children.forEach((child) => {
            flatten(child);
          });
        }
      }
      tree.forEach((node) => {
        flatten(node);
      });
      return result;
    },

    // 变为true
    findAndUpdateItemsByIds(tree, ids, state) {
      function findAndUpdate(node) {
        if (ids.includes(node.id)) {
          node.checked = state; // 将目标项的 check 属性设置为 true
        }
        if (node.children && node.children.length > 0) {
          for (let child of node.children) {
            findAndUpdate(child); // 递归处理子节点
          }
        }
      }
      for (let node of tree) {
        findAndUpdate(node); // 对每个顶层节点执行查找和更新操作
      }
      return tree; // 返回修改后的完整数组
    },

    // 全选
    checkAll() {
      const ids = [];
      let list = [];
      let checked = "";
      this.properties.treeList.forEach((item) => {
        if (item.children && item.children.length > 0) {
          list.push(...this.flattenTree([item]));
        }
      });
      list = list.filter(item => !item.disabled)
      list.forEach((item) => {
        ids.push(item.id);
        checked = item.checked;
      });
      const flag = this.properties.checkAllState;
      var myEventDetail = {
        ids,
        flag,
      };
      var myEventOption = {
        bubbles: true,
        composed: true,
      };
      this.triggerEvent("changeListChecked", myEventDetail, myEventOption);
      var myEventDetail = {
        value: !flag,
      }; // detail对象，提供给事件监听函数
      var myEventOption = {
        bubbles: true,
        composed: true,
      }; // 触发事件的选项
      this.triggerEvent("changeCheckAll", myEventDetail, myEventOption);
    },

    // 章节勾选
    checkResourceTitle(e) {
      const flag = e.detail.checked;
      // 这个时候checked的值是fals
      const item = e.currentTarget.dataset.item;
      const parent = this.findParentById(this.properties.learnList, item.id);
      let childrenList = [];
      let flagNum;
      if (parent)
        childrenList = parent.children.filter((citem) => citem.id !== item.id);
      flagNum = childrenList.findIndex((item) => item.checked == false);
      let list = this.flattenTree([item]);
      list = list.filter(item => !item.disabled)
      let ids = [];
      list.forEach((item) => {
        ids.push(item.id)
      });
      var myEventDetail = {
        ids,
        flag,
      }; // detail对象，提供给事件监听函数
      var myEventOption = {
        bubbles: true,
        composed: true,
      }; // 触发事件的选项
      // 去勾选点击目录的子项
      this.triggerEvent("changeListChecked", myEventDetail, myEventOption);
      // 去勾选点击目录的父项
      if (flagNum == -1 && parent && !parent.disabled) {
        let checkedState;
        var myEventDetail = {
          ids: [parent.id],
          flag,
        };
        var myEventOption = {
          bubbles: true,
          composed: true,
        };
        this.triggerEvent("changeListChecked", myEventDetail, myEventOption);
      }
      list.forEach((items) => {
        if (!items.checked) {
          this.setData({
            cloudShoppingCart: items,
          });
        }
      });
      this.setData({
        openIds: this.data.openIds,
      });
    },
    // 子项勾选
    checkResource(e) {
      const citem = e.currentTarget.dataset.item;
      const parent = e.currentTarget.dataset.parent;
      let outermost;
      if (parent)
        outermost = this.findParentById(this.properties.learnList, parent.id);
      const childrenList = parent.children.filter(
        (item) => item.id !== citem.id && item.saleMethod.length
      );
      const flag = childrenList.findIndex((item) => item.checked == false);
      // 改变该项checked
      var myEventDetail = {
        id: citem.id,
      };
      var myEventOption = {
        bubbles: true,
        composed: true,
      };
      this.triggerEvent("changeResourceChecked", myEventDetail, myEventOption);
      // 通过判断,联通父级checked
      if (flag == -1 && !parent.disabled) {
        let checkedState;
        citem.checked == false ? (checkedState = true) : (checkedState = false);
        var myEventDetail = {
          ids: [parent.id],
          flag: checkedState,
        };
        var myEventOption = {
          bubbles: true,
          composed: true,
        };
        this.triggerEvent("changeListChecked", myEventDetail, myEventOption);
      }
      // 联通最外层级checked ,如果有一个取消勾选,且当前最外层勾选,则取消最外层的勾选
      if (citem.checked && outermost && outermost.checked) {
        var myEventDetail = {
          ids: [outermost.id],
          flag: false,
        };
        var myEventOption = {
          bubbles: true,
          composed: true,
        };
        this.triggerEvent("changeListChecked", myEventDetail, myEventOption);
      }
      // 联通最外层级checked, 如果所有子项勾选, 且当前最外层未勾选, 则加上最外层的勾选
      if (!citem.checked && outermost && !outermost.disabled) {
        let allchildren = this.flattenTree([outermost]);
        allchildren = allchildren.filter(
          (item) =>
          item.sysType == "CmsItem" &&
          item.id !== citem.id &&
          item.saleMethod.length
        );
        const satate = allchildren.findIndex((item) => item.checked == false);
        if (satate == -1) {
          var myEventDetail = {
            ids: [outermost.id],
            flag: true,
          };
          var myEventOption = {
            bubbles: true,
            composed: true,
          };
          this.triggerEvent("changeListChecked", myEventDetail, myEventOption);
        }
      }
    },
    // 加入购物车
    async onCloudShoppingCart(e) {
      let shoppingCartGetId = [];
      const item = e.currentTarget.dataset.item;
      const saleMethodId = e.currentTarget.dataset.item.saleMethod[0].Id;
      let query = {
        start: 0,
        size: 999,
        filterList: [],
        searchList: [],
      };
      const res = await app.MG.store.getShoppingCartProductList(query);
      res.datas.forEach((item) => {
        shoppingCartGetId.push(item.saleMethod.id);
      });
      if (shoppingCartGetId.includes(saleMethodId)) {
        wx.showToast({
          icon: "error",
          title: "已添加",
        });
        this.setData({
          shoppingCart: false,
        });
      } else {
        let query = {
          requests: [{
            saleMethodId: saleMethodId,
            storeEventId: null,
            // agentCode: '电子书'
          }, ],
        };
        const addRes = await app.MG.store.addShoppingCart(query);
        if (addRes) {
          wx.showToast({
            icon: "success",
            title: "添加成功",
          });
          item.isShopCar = false;
          var myEventDetail = {
            id: item.id,
          };
          var myEventOption = {
            bubbles: true,
            composed: true,
          };
          this.triggerEvent("updateCloudLearning", myEventDetail, myEventOption);
        }
      }
    },
    sadd() {
      this.triggerEvent("updateShoppingCartHidden");
      this.triggerEvent("updateCloudLearning");
    },
    findParentById(arr, id) {
      for (let i = 0; i < arr.length; i++) {
        const item = arr[i];
        // 检查当前项是否匹配（即它是不是我们要找的项）
        if (item.id === id) {
          // 如果当前项就是我们要找的项，则它没有父级，返回 null
          return null;
        }
        // 递归查找当前项的子项
        const child = this.findChildById(item.children, id);
        if (child) {
          // 如果在子项中找到匹配的项，返回当前项作为父级
          return item;
        }
      }
      // 如果没有找到匹配的父项，返回 null
      return null;
    },
    // 辅助函数，用于递归查找子项
    findChildById(children, id) {
      if (!children) {
        return null;
      }
      for (let i = 0; i < children.length; i++) {
        const child = children[i];
        if (child.id === id) {
          // 如果找到匹配的项，返回它
          return child;
        }
        // 递归检查子项的子项
        const subChild = this.findChildById(child.children, id);
        if (subChild) {
          return subChild;
        }
      }
      // 如果没有找到匹配的项，返回 null
      return null;
    },
  },
});