const app = getApp();
const {
  get,
  post
} = require('../../api/request');
const dayjs = require('dayjs');

Page({
  /**
   * 页面的初始数据
   */
  data: {
    // 表单数据
    planCode: '', // 计划编号
    startTime: '', // 灌溉开始时间
    pickerValue: '', // 时间选择器的值
    timePickerVisible: false, // 时间选择器是否可见
    timeInfoVisible: false, // 时间提示弹窗是否可见
    // 项目选择器相关
    projectPickerVisible: false,
    projectPickerValue: [],
    selectedProject: null,
    projectOptions: [],
    totalDuration: 0, // 添加总灌溉时间
    // 项目列表
    projectList: [],
    // 时间选择器选项
    timeOptions: [],
    // 轮灌组列表刷新状态
    isRefreshing: false
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    // 生成计划编号
    this.generatePlanCode();
    // 设置时间选择器的初始值
    const now = dayjs();
    this.setData({
      pickerValue: now.add(8.5, 'hour').format('YYYY-MM-DD HH:mm')
    });
    // 获取项目列表
    this.fetchProjects();
  },

  /**
   * 生成计划编号
   */
  generatePlanCode: function () {
    const now = dayjs();
    const dateStr = now.format('YYYY-MM-DD');
    const randomNum = Math.floor(Math.random() * 10000).toString().padStart(4, '0');
    const planCode = `${dateStr}${-randomNum}`;
    this.setData({
      planCode
    });
  },

  /**
   * 获取项目列表
   */
  fetchProjects: function (isShowDiaolog) {
    return get({
      url: '/wx/irrigation/getSimpleProjects',
      isShowLoding: true
    }).then(res => {
      if (res.success) {
        const projectList = res.content.map(project => ({
          id: project.projectId,
          name: project.projectName,
          groupCount: project.groupCount,
          groups: []
        }));

        const projectOptions = projectList.map(project => ({
          label: project.name,
          value: project.id
        }));

        this.setData({
          projectList,
          projectOptions
        });
        if (isShowDiaolog) {
          this.setData({
            projectPickerVisible: true
          });
        }
      } else {
        wx.showToast({
          title: res.msg || '获取项目列表失败',
          icon: 'none'
        });
        return Promise.reject(new Error(res.msg || '获取项目列表失败'));
      }
    }).catch(err => {
      console.error('获取项目列表失败：', err);
      wx.showToast({
        title: '获取项目列表失败',
        icon: 'none'
      });
      return Promise.reject(err);
    });
  },

  /**
   * 获取轮灌组列表
   */
  fetchGroups: function (projectId) {
    return get({
      url: '/wx/irrigation/getSimpleGroups',
      data: {
        projectId: projectId,
      },
      isShowLoding: true
    }).then(res => {
      if (res.success) {
        console.log('轮灌组数据：', res.content);

        // 更新选中项目的轮灌组信息
        const projectList = this.data.projectList.map(project => {
          if (project.id === projectId) {
            return {
              ...project,
              groups: res.content.map(group => ({
                id: group.groupId,
                name: group.groupCode,
                duration: group.defaultDuration || 0,
                selected: false,
                intakeCount: group.intakeCount
              }))
            };
          }
          return project;
        });

        // 更新选中的项目
        const selectedProject = projectList.find(project => project.id === projectId);
        console.log('更新后的选中项目：', selectedProject);

        this.setData({
          projectList,
          selectedProject
        }, () => {
          // 计算总时间
          this.calculateTotalDuration();
        });
      } else {
        wx.showToast({
          title: res.msg || '获取轮灌组列表失败',
          icon: 'none'
        });
        return Promise.reject(new Error(res.msg || '获取轮灌组列表失败'));
      }
    }).catch(err => {
      console.error('获取轮灌组列表失败：', err);
      wx.showToast({
        title: '获取轮灌组列表失败',
        icon: 'none'
      });
      return Promise.reject(err);
    });
  },

  /**
   * 显示时间选择器
   */
  showTimePicker: function () {
    // 如果没有选择时间，使用当前时间
    if (!this.data.pickerValue) {
      const now = dayjs();
      this.setData({
        pickerValue: now.format('YYYY-MM-DD HH:mm')
      });
    }

    this.setData({
      timePickerVisible: true
    });
  },

  /**
   * 时间选择器确认回调
   */
  onTimePickerConfirm: function (e) {
    const {
      value
    } = e.detail;
    this.setData({
      timePickerVisible: false,
      startTime: value
    });
  },

  /**
   * 时间选择器取消回调
   */
  onTimePickerCancel: function () {
    this.setData({
      timePickerVisible: false
    });
  },

  /**
   * 切换项目展开/折叠状态
   */
  toggleProject: function (e) {
    const index = e.currentTarget.dataset.index;
    const currentValue = this.data.projectList[index].expanded;

    // 创建新的项目列表，先将所有项目设为折叠状态
    const newProjectList = this.data.projectList.map((item, idx) => {
      return {
        ...item,
        expanded: false
      };
    });

    // 如果当前点击的项目已经是展开状态，则保持所有项目折叠
    // 否则，将当前点击的项目设为展开状态
    if (!currentValue) {
      newProjectList[index].expanded = true;
    }

    this.setData({
      projectList: newProjectList
    });
  },

  /**
   * 切换轮灌组选中状态
   */
  toggleGroupSelection: function (e) {
    const projectIndex = e.currentTarget.dataset.projectIndex;
    const groupIndex = e.currentTarget.dataset.groupIndex;
    const key = `projectList[${projectIndex}].groups[${groupIndex}].selected`;
    const currentValue = this.data.projectList[projectIndex].groups[groupIndex].selected;

    this.setData({
      [key]: !currentValue
    });

    // 更新项目总时长
    this.updateProjectTotalDuration(projectIndex);
  },

  /**
   * 处理时长输入
   */
  onDurationInput: function (e) {
    const {
      groupIndex
    } = e.currentTarget.dataset;
    const duration = parseInt(e.detail.value) || 0;

    const selectedProject = {
      ...this.data.selectedProject
    };
    selectedProject.groups[groupIndex].duration = duration;

    this.setData({
      selectedProject
    }, () => {
      // 输入时长后重新计算总时间
      this.calculateTotalDuration();
    });
  },

  /**
   * 计算并更新项目总时长
   */
  updateProjectTotalDuration: function (projectIndex) {
    const project = this.data.projectList[projectIndex];
    let totalDuration = 0;

    // 计算所有选中的轮灌组的时长总和
    project.groups.forEach(group => {
      if (group.selected) {
        totalDuration += parseInt(group.duration) || 0;
      }
    });

    // 更新项目总时长
    const totalDurationKey = `projectList[${projectIndex}].totalDuration`;
    this.setData({
      [totalDurationKey]: totalDuration
    });
  },

  /**
   * 阻止事件冒泡
   */
  stopPropagation: function (e) {
    if (e && e.stopPropagation) {
      e.stopPropagation();
    }
    return false;
  },

  /**
   * 跳转到轮灌组详情页
   */
  navigateToGroupDetail: function (e) {
    const {
      groupIndex
    } = e.currentTarget.dataset;
    // TODO: 实现跳转逻辑
  },

  /**
   * 确认按钮点击事件
   */
  onConfirm: function () {
    const {
      planCode,
      startTime,
      selectedProject
    } = this.data;

    if (!planCode) {
      wx.showToast({
        title: '请输入计划编号',
        icon: 'none'
      });
      return;
    }

    if (!selectedProject) {
      wx.showToast({
        title: '请选择项目',
        icon: 'none'
      });
      return;
    }

    // 构建上报数据
    const schedules = selectedProject.groups.map(group => ({
      groupId: group.id,
      duration: parseInt(group.duration) || 0
    }));

    const requestData = {
      projectId: selectedProject.id,
      planName: planCode,
      startupMode: startTime ? 2 : 1,
      operatorId: app.globalData.clientId,
      schedules: schedules
    };

    // 如果有开始时间，添加到请求数据中
    if (startTime) {
      requestData.planStartTime = startTime;
    }

    // 发送请求
    post({
      url: '/wx/plan/createPlan',
      data: requestData,
      isShowLoding: true
    }).then(res => {
      if (res.success) {
        wx.showToast({
          title: '创建成功',
          icon: 'success'
        });
        // 返回上一页，并传递参数指示需要刷新列表并切换到当前计划列表
        setTimeout(() => {
          // 使用全局变量标记需要刷新
          const app = getApp();
          app.globalData.needRefreshIrrigationList = true;

          // 直接返回上一页
          wx.navigateBack({
            delta: 1
          });
        }, 1500);
      } else {
        wx.showToast({
          title: res.msg || '创建失败',
          icon: 'none'
        });
      }
    }).catch(err => {
      console.error('创建计划失败：', err);
      wx.showToast({
        title: '创建失败',
        icon: 'none'
      });
    });
  },

  // 显示项目选择器
  showProjectPicker() {
    this.fetchProjects(true)

  },

  // 项目选择器确认
  onProjectPickerConfirm(e) {
    const {
      value
    } = e.detail;
    console.log('选择的项目ID：', value[0]); // 添加日志查看数据
    const selectedProject = this.data.projectList.find(project => project.id === value[0]);
    console.log('找到的项目：', selectedProject); // 添加日志查看数据

    this.setData({
      projectPickerVisible: false,
      selectedProject: selectedProject,
      projectPickerValue: value
    }, () => {
      // 选择项目后获取轮灌组列表
      if (selectedProject) {
        this.fetchGroups(selectedProject.id);
      }
    });
  },

  // 项目选择器取消
  onProjectPickerCancel() {
    this.setData({
      projectPickerVisible: false
    });
  },

  /**
   * 计算总灌溉时间
   */
  calculateTotalDuration: function () {
    if (!this.data.selectedProject) return;

    const totalDuration = this.data.selectedProject.groups.reduce((sum, group) => {
      return sum + (parseInt(group.duration) || 0);
    }, 0);

    this.setData({
      totalDuration
    });
  },

  /**
   * 轮灌组列表下拉刷新
   */
  onGroupListRefresh: function () {
    if (!this.data.selectedProject) {
      this.setData({
        isRefreshing: false
      });
      return;
    }

    this.setData({
      isRefreshing: true
    });

    this.fetchGroups(this.data.selectedProject.id)
      .then(() => {
        this.setData({
          isRefreshing: false
        });
      })
      .catch(() => {
        this.setData({
          isRefreshing: false
        });
      });
  },

  /**
   * 显示时间提示弹窗
   */
  showTimeInfo: function () {
    this.setData({
      timeInfoVisible: true
    });
  },

  /**
   * 关闭时间提示弹窗
   */
  onTimeInfoConfirm: function () {
    this.setData({
      timeInfoVisible: false
    });
  },
});