export const filter = {
	/**
	 * 过滤获取到的数据 根据开始截止时间
	 * @param {object} data 缓存拿到的数据
	 * @param {number} start ms
	 * @param {number} end ms
	 * @returns
	 */
	projects(data, start, end) {
		if (!data || !data.length) return [];
		return data.filter(item => start <= +item.endTime && end >= +item.startTime);
	},

  /**
   * 角色 过滤获取到的数据 根据开始截止时间
   * @param {object} data 缓存拿到的数据
   * @returns
   */
  // roles(data) {
  //   if (!data) return [];
  //   return data;
  // },

  /**
   * 日常任务 过滤获取到的数据 根据开始截止时间
   * @param {object} data 缓存拿到的数据
   * @param {number} timeNode 时间基准点 ms
   * @returns
   */
  dailyTask(data, timeNode) {
    if (!data || !data.length) return [];
    // TODO: 缺少通过时间颗粒度筛选数据 任务没有返回时间颗粒度标签
    return data.filter(item => timeNode <= +item.endTime && timeNode >= +item.startTime);
  },

  /**
   * 永久日常任务 过滤获取到的数据 根据开始截止时间
   * @param {object} data 缓存拿到的数据
   * @returns
   */
  fixedTasks(data) {
    if (!data || !data.length) return [];
    return data;
  },

  /**
   * 定期任务 过滤获取到的数据 根据开始截止时间
   * @param {object} data 缓存拿到的数据
   * @param {number} timeNode 时间基准点 ms
   * @param {number} queryNum 颗粒度数量
   * @param {number} timeUnit 时间颗粒度
   * @param {number} queryType 0向上查找 1向下查找(默认) 下查包含自己，上查不包含
   * @returns
   */
  planTask(data, timeNode, queryNum, timeUnit, queryType) {
    if (!data || !data.length) return [];
    if (queryType === 0) {
      // 计算颗粒度 对应的 dayjs add 的单位
      let target = uni.$t.timeConfig.timeUnits.find(item => item.id === timeUnit);
      // TODO: 缺少通过时间颗粒度筛选数据 任务没有返回时间颗粒度标签
      let start = uni.$t.time.add(+timeNode, -queryNum, target.granularity).valueOf();
      let arr = [];
      arr = data.filter(item => start <= +item.planStart && +timeNode > +item.planEnd);

      if (!arr || !arr.length) {
        // 开始时间往前推
        let resultS = [];
        let againStart = uni.$t.time.add(start, -1, target.granularity).valueOf();
        let againArr = data.filter(item => againStart >= +item.planStart);
        if (againArr && againArr.length) {
          let sTime = uni.$t.time.setTimestampToStr(+againArr[0].planStart);
          data.forEach(item => {
            if (uni.$t.time.isSame(uni.$moment(sTime.date).valueOf(), +item.planStart, target.granularity)) {
              resultS.push(item);
            }
          });
        }
        return resultS;
      } else {
        return arr;
      }
    } else {
      // 计算颗粒度 对应的 dayjs add 的单位
      let target = uni.$t.timeConfig.timeUnits.find(item => item.id === timeUnit);
      // TODO: 缺少通过时间颗粒度筛选数据 任务没有返回时间颗粒度标签
      let end = uni.$t.time.add(timeNode, +queryNum - 1, target.granularity).valueOf();
      let arr = [];
      arr = data.filter(item => end >= +item.planEnd && +timeNode <= +item.planStart);

      if (!arr || !arr.length) {
        // 结束时间往后推
        let resultE = [];
        let againEnd = uni.$t.time.add(end, 1, target.granularity).valueOf();
        let againEndArr = data.filter(item => againEnd <= +item.planStart);
        if (againEndArr) {
          let eTime = uni.$t.time.setTimestampToStr(+againEndArr[againEndArr.length - 1].planStart);
          data.forEach(item => {
            if (uni.$t.time.isSame(uni.$moment(eTime.date).valueOf(), +item.planEnd, target.granularity)) {
              resultE.push(item);
            }
          });
        }
        return resultE;
      } else {
        return arr;
      }
    }
  },

  /**
   * 插件 过滤获取到的数据 根据插件id
   * @param {object} data 缓存拿到的数据
   * @returns
   */
  plugin(data) {
    if (!data || !data.id) return null;
    return data;
  },
};

export default {
  /**
   * 广告、引导页
   */
  async getGuideByType(type) {
    try {
      const data = type === 0 ? await uni.$storage.getStorage('guide') : await uni.$storage.getStorage('advs');
      return data;
    } catch(error) {
      return '';
    }
  },

  putGuide(data, type) {
    try {
    	if (!data) return; // 服务端没数据不做操作
    	let locals = data;
    	uni.$storage.setStorage('projects', locals);
      type ? uni.$storage.setStorage('advs', locals) : uni.$storage.setStorage('guide', locals);
    } catch (error) {
      type ? uni.$storage.setStorage('advs', '') : uni.$storage.setStorage('guide', '');
    }
  },

	/**
	 * 项目列表某天的 获取
	 * @param {number} startTime
	 * @param {number} endTime
	 * @returns
	 */
	async getProjectsByDay(startTime, endTime) {
		try {
			const data = await uni.$storage.getStorage('projects');
			return filter.projects(JSON.parse(data), startTime, endTime);
		} catch (error) {
			return [];
		}
	},

	/**
	 * 项目列表 存
	 * @param {array} data
	 */
	putProjects(data) {
		try {
			if (!data || !data.length) return; // 服务端没数据不做操作
			let value = uni.$storage.getStorageSync('projects');
			let locals = value ? JSON.parse(value) : [];
			if (!locals || !locals.length) {
				// 本地没数据
				locals = data || [];
			} else {
				// 本地有数据
				data.forEach(item => {
					let localData = locals.find(local => item.id === local.id);
					if (localData) {
						// 有相同数据  就用新的data里的数据
						localData = item;
					} else {
						// 没有就直接存本地
						locals.push(item);
					}
				});
			}
			uni.$storage.setStorage('projects', locals);
		} catch (error) {
			console.error('error: ', error);
			uni.$storage.setStorage('projects', []);
		}
	},

  /**
   * 当前显示的角色信息 获取
   * @param {object} params
   * @returns
   */
  async getShowRole(projectId) {
    try {
      const data = await uni.$storage.getStorage(`roles_${projectId}`);
      return filter.roles(JSON.parse(data));
    } catch (error) {
      return null;
    }
  },

  /**
   * 当前显示的角色信息 存
   * @param {array} data
   */
  putShowRole(projectId, data) {
    try {
      if (!data || !data.visibleList || !data.visibleList.length) return; // 服务端没数据不做操作
      let value = uni.$storage.getStorageSync(`roles_${projectId}`);
      let locals = value ? JSON.parse(value) : null;
      if (!locals || !locals.length) {
        // 本地没数据
        locals = data || null;
      } else {
        // 本地有数据
        data.invisibleList.forEach(item => {
          let invisibleListLocalData = locals.invisibleList.find(local => item.id === local.id);
          if (invisibleListLocalData) {
            // 有相同数据  就用新的data里的数据
            invisibleListLocalData = item;
          } else {
            // 没有就直接存本地
            locals.invisibleList.push(item);
          }
        });
        data.visibleList.forEach(item => {
          let localData = locals.visibleList.find(local => item.id === local.id);
          if (localData) {
            // 有相同数据  就用新的data里的数据
            localData = item;
          } else {
            // 没有就直接存本地
            locals.visibleList.push(item);
          }
        });
      }
      uni.$storage.setStorage(`roles_${projectId}`, locals);
    } catch (error) {
      console.error('error: ', error);
      uni.$storage.setStorage(`roles_${projectId}`, []);
    }
  },

  /**
   * 定期任务 获取
   * @param {number} startTime
   * @param {number} endTime
   * @returns
   */
  async getStorageRegularTask(params) {
    try {
      const data = await uni.$storage.getStorage(`plan_task_${params.projectId}_${params.roleId}`);
      return filter.planTask(JSON.parse(data), params.timeNode, params.queryNum, params.timeUnit, params.queryType);
    } catch (error) {
      return [];
    }
  },

  /**
   * 定期任务 存
   * @param {array} data
   */
  putStorageRegularTask(params, data) {
    try {
      if (!data || !data.length) return; // 服务端没数据不做操作
      let value = uni.$storage.getStorageSync(`plan_task_${params.projectId}_${params.roleId}`);
      let locals = value ? JSON.parse(value) : [];
      if (!locals || !locals.length) {
        // 本地没数据
        locals = data || [];
      } else {
        // 本地有数据
        data.forEach(item => {
          let localData = locals.find(local => item.id === local.id);
          if (localData) {
            // 有相同数据  就用新的data里的数据
            localData = item;
          } else {
            // 没有就直接存本地
            locals.push(item);
          }
        });
      }
      uni.$storage.setStorage(`plan_task_${params.projectId}_${params.roleId}`, locals);
    } catch (error) {
      console.error('error: ', error);
      uni.$storage.setStorage(`plan_task_${params.projectId}_${params.roleId}`, []);
    }
  },

  /**
   * 永久的日常任务 获取
   * @param {number} startTime
   * @param {number} endTime
   * @returns
   */
  async getStoragePermanent(params) {
    try {
      const data = await uni.$storage.getStorage(`fixed_tasks_${params.projectId}_${params.roleId}`);
      return filter.fixedTasks(JSON.parse(data));
    } catch (error) {
      return [];
    }
  },

  /**
   * 永久的日常任务 存
   * @param {array} data
   */
  putStoragePermanent(params, data) {
    try {
      if (!data || !data.length) return; // 服务端没数据不做操作
      let value = uni.$storage.getStorageSync(`fixed_tasks_${params.projectId}_${params.roleId}`);
      let locals = value ? JSON.parse(value) : [];
      if (!locals || !locals.length) {
        // 本地没数据
        locals = data || [];
      } else {
        // 本地有数据
        data.forEach((item, index) => {
          let localData = locals.find(local => item.detailId === local.detailId);
          if (localData) {
            // 有相同数据  就用新的data里的数据
            localData = item;
          } else {
            locals.splice(index, 1);
            // 没有就直接存本地
            locals.push(item);
          }
        });
      }
      uni.$storage.setStorage(`fixed_tasks_${params.projectId}_${params.roleId}`, locals);
    } catch (error) {
      console.error('error: ', error);
      uni.$storage.setStorage(`fixed_tasks_${params.projectId}_${params.roleId}`, []);
    }
  },

  /**
   * 日常任务 获取
   * @param {number} timeNode
   * @returns
   */
  async getDailyTask(params) {
    try {
      const data = await uni.$storage.getStorage(`variable_tasks_${params.projectId}_${params.roleId}`);
      return filter.dailyTask(JSON.parse(data), params.timeNode);
    } catch (error) {
      return [];
    }
  },

  /**
   * 日常任务 存
   * @param {array} data
   */
  putDailyTask(params, data) {
    try {
      if (!data || !data.length) return; // 服务端没数据不做操作
      let value = uni.$storage.getStorageSync(`variable_tasks_${params.projectId}_${params.roleId}`);
      let locals = value ? JSON.parse(value) : [];
      if (!locals || !locals.length) {
        // 本地没数据
        locals = data || [];
      } else {
        // 本地有数据
        data.forEach(item => {
          let localData = locals.find(local => item.detailId === local.detailId);
          if (localData) {
            // 有相同数据  就用新的data里的数据
            localData = item;
          } else {
            // 没有就直接存本地
            locals.push(item);
          }
        });
      }
      uni.$storage.setStorage(`variable_tasks_${params.projectId}_${params.roleId}`, locals);
    } catch (error) {
      console.error('error: ', error);
      uni.$storage.setStorage(`variable_tasks_${params.projectId}_${params.roleId}`, []);
    }
  },

  /**
   * 插件信息 获取
   * @param {string} pluginId
   * @returns
   */
  async getPlugin(pluginId) {
    try {
      const data = await uni.$storage.getStorage(`plugin_${pluginId}`);
      return filter.plugin(JSON.parse(data));
    } catch (error) {
      return null;
    }
  },

  /**
   * 插件信息 存
   * @param {string} pluginId
   * @param {object} data
   */
  putPlugin(pluginId, data) {
    try {
      if (!data || !data.id) return; // 服务端没数据不做操作
      let value = uni.$storage.getStorageSync(`plugin_${pluginId}`);
      let locals = value ? JSON.parse(value) : null;
      if (!locals || !locals.length) {
        // 本地没数据
        locals = data || null;
      } else {
        // 本地有数据
        locals = data;
      }
      uni.$storage.setStorage(`plugin_${pluginId}`, locals);
    } catch (error) {
      console.error('error: ', error);
      uni.$storage.setStorage(`plugin_${pluginId}`, null);
    }
  },
};