注册永久免费域名，托管到 CloudFlare ，自动免费续订、提醒！

热门2026-01-072026-01-10

注册永久免费域名，托管到 CloudFlare ，自动免费续订、提醒！

今天给大家推荐一个稳定又非常不错的免费域名注册方案，
来自非盈利组织：digitalplat，
申请注册后可以直接托管到CloudFlare 平台上进行管理使用。

Cloudflare 服务

目前免费的后缀是 .dpdns.org ，比如我输入域名：shumajiema.dpdns.org 是可以直接免费注册的

2、接下来只需注册一个账号就能获取到免费域名，【免费注册】注册好以后通过这个链接进行登入【点击登录】

注册用户的时候，务必使用自己常用的邮箱，否则将来忘记密码或者免费续订的时候不会出现问题。
phone电话栏可以随便填：+1-3477700244
Full address地址栏可以随便填，也可以填我这个：26 Gateway road,portland,97205 只要把前面的数字修改一下就行。
最后填写以下密码。
然后通过你注册的邮箱会收到个链接，然后你把链接打开激活一下就可以了。
注册域名后服务器名称这里可以先填：

Name Server 1* 名称服务器 1
daisy.ns.cloudflare.com
Name Server 2* 名称服务器 2
magali.ns.cloudflare.com

完成后再复制cf上的服务器去修改域名的服务器然后新。
之后它会显示注册成功。

3、把域名托管到 CloudFlare ，方便统一管理【点击前往】
域名托管服务

点击查看:【视频教程】

4、免费域名需要每 180 天续期一次。可以使用 SubsTracker 来进行订阅提醒，不至于忘记续订，虽然是免费续订的，但是每隔180天需要续订下。

订阅提醒部署：

1.登陆Cloudflare,创建worker,粘贴本项目中的js代码,【点击获取】

2.在Cloudflare 点击左侧：存储和数据库 – KV -创建KV – 用户和键值都填写：python SUBSCRIPTIONS_KV

3.给worker绑定上键值对,【以及设置定时执行时间!】注意：这里的名称一定是：SUBSCRIPTIONS_KV 否则后面需修改参数无法保存！

自动托管代码我已经整理好了:

// 订阅续期通知网站 - 基于CloudFlare Workers (完全优化版)

// 时区处理工具函数
// 常量：每秒转换为小时/天，全局复用
const MS_PER_HOUR = 1000 * 60 * 60;
const MS_PER_DAY = MS_PER_HOUR * 24;

function getCurrentTimeInTimezone(timezone = 'UTC') {
  尝试 {
    // Workers 环境下 Date 始终存储 UTC 时间，这里直接返回当前时间对象
    返回新的 Date()；
  } catch (error) {
    console.error(`时区转换错误: ${error.message}`);
    // 如果时区无效，返回UTC时间
    返回新的 Date()；
  }
}

function getTimestampInTimezone(timezone = 'UTC') {
  返回 getCurrentTimeInTimezone(timezone).getTime();
}

function convertUTCToTimezone(utcTime, timezone = 'UTC') {
  尝试 {
    // 同 getCurrentTimeInTimezone，一律返回 Date 供后续统一处理
    返回新的 Date(utcTime)；
  } catch (error) {
    console.error(`时区转换错误: ${error.message}`);
    返回新的 Date(utcTime)；
  }
}

// 获取指定时区的年/月/日/时/分/秒，可以避免重复的国际解析逻辑
function getTimezoneDateParts(date, timezone = 'UTC') {
  尝试 {
    const formatter = new Intl.DateTimeFormat('en-US', {
      时区：时区，
      hour12：否，
      年份：'数字'，月份：'两位数'，日期：'两位数'，
      小时：两位数，分钟：两位数，秒：两位数
    });
    const parts = formatter.formatToParts(date);
    const pick = (type) => {
      const part = parts.find(item => item.type === type);
      返回部件值？Number(部件.值) : 0；
    };
    返回 {
      年份：pick('year')，
      月份：选择('月份')，
      day: pick('day'),
      小时：选择('小时')，
      分钟：选择('分钟')，
      second: pick('second')
    };
  } catch (error) {
    console.error(`解析时区(${timezone})失败: ${error.message}`);
    返回 {
      年份：date.getUTCFullYear()，
      月份：date.getUTCMonth() + 1，
      day: date.getUTCDate(),
      小时：date.getUTCHours()，
      分钟：date.getUTCMinutes()，
      秒：date.getUTCSeconds()
    };
  }
}

// 计算指定日期在目标时区的午夜（毫秒），用于统一的“剩余天数”计算
function getTimezoneMidnightTimestamp(date, timezone = 'UTC') {
  const { year, month, day } = getTimezoneDateParts(date, timezone);
  返回 Date.UTC(年, 月 - 1, 日, 0, 0, 0);
}

function calculateExpirationTime(expirationMinutes, timezone = 'UTC') {
  const currentTime = getCurrentTimeInTimezone(timezone);
  const expirationTime = new Date(currentTime.getTime() + (expirationMinutes * 60 * 1000));
  返回过期时间；
}

function isExpired(targetTime, timezone = 'UTC') {
  const currentTime = getCurrentTimeInTimezone(timezone);
  const target = new Date(targetTime);
  返回当前时间大于目标时间；
}

function formatTimeInTimezone(time, timezone = 'UTC', format = 'full') {
  尝试 {
    const date = new Date(time);
    
    如果 (format === 'date') {
      返回 date.toLocaleDateString('zh-CN', {
        时区：时区，
        年份：'数字'，
        月份：两位数，
        日期：两位数
      });
    } else if (format === 'datetime') {
      返回 date.toLocaleString('zh-CN', {
        时区：时区，
        年份：'数字'，
        月份：两位数，
        日期：两位数
        小时：两位数，
        分钟：'两位数'，
        第二个：'两位数'
      });
    } 别的 {
      // 完整格式
      返回 date.toLocaleString('zh-CN', {
        时区：时区
      });
    }
  } catch (error) {
    console.error(`时间整理错误: ${error.message}`);
    返回新的 Date(time).toISOString();
  }
}

function getTimezoneOffset(timezone = 'UTC') {
  尝试 {
    const now = new Date();
    const { year, month, day, hour, minute, second } = getTimezoneDateParts(now, timezone);
    const zonedTimestamp = Date.UTC(year, month - 1, day, hour, minute, second);
    返回 Math.round((zonedTimestamp - now.getTime()) / MS_PER_HOUR);
  } catch (error) {
    console.error(`获取时区偏移量错误: ${error.message}`);
    返回 0；
  }
}

// 格式化时区显示，包含UTC偏移
function formatTimezoneDisplay(timezone = 'UTC') {
  尝试 {
    const offset = getTimezoneOffset(timezone);
    const offsetStr = offset >= 0 ? `+${offset}` : `${offset}`;
    
    // 时区中文名称地图
    const timezoneNames = {
      'UTC': '世界标准时间',
      '亚洲/上海': '中国标准时间',
      'Asia/Hong_Kong': '香港时间',
      '亚洲/台北': '台北时间',
      '亚洲/新加坡': '新加坡时间',
      '亚洲/东京': '日本时间',
      '亚洲/首尔': '韩国时间',
      'America/New_York': '美国东部时间',
      'America/Los_Angeles': '美国太平洋时间',
      'America/Chicago': '美国中部时间',
      'America/Denver': '美国山地时间',
      '欧洲/伦敦': '英国时间',
      '欧洲/巴黎': '巴黎时间',
      'Europe/Berlin': '柏林时间',
      '欧洲/莫斯科': '莫斯科时间',
      '澳大利亚/悉尼': '悉尼时间',
      '澳大利亚/墨尔本': '墨尔本时间',
      “太平洋/奥克兰”：“奥克兰时间”
    };
    
    const timezoneName = timezoneNames[timezone] || timezone;
    返回 `${timezoneName} (UTC${offsetStr})`；
  } catch (error) {
    console.error('格式化时区显示失败:', error);
    返回时区；
  }
}

// 兼容性函数 - 保持原有接口
function formatBeijingTime(date = new Date(), format = 'full') {
  return formatTimeInTimezone(date, 'Asia/Shanghai', format);
}

// 时区处理中间件函数
function extractTimezone(request) {
  // 优先级：URL参数 > 请求头 > 默认值
  const url = new URL(request.url);
  const timezoneParam = url.searchParams.get('timezone');
  
  如果 (timezoneParam) {
    返回 timezoneParam；
  }
  
  // 从请求头获取时区
  const timezoneHeader = request.headers.get('X-Timezone');
  如果 (timezoneHeader) {
    返回时区标头；
  }
  
  // 从Accept-Language头推断时区（简化处理）
  const acceptLanguage = request.headers.get('Accept-Language');
  如果 (接受语言) {
    // 简单的时区推断逻辑
    如果 (acceptLanguage.includes('zh')) {
      返回'Asia/Shanghai'；
    } else if (acceptLanguage.includes('en-US')) {
      返回'America/New_York'；
    } else if (acceptLanguage.includes('en-GB')) {
      返回'Europe/London'；
    }
  }
  
  // 默认返回UTC
  返回'UTC'；
}

function isValidTimezone(timezone) {
  尝试 {
    // 尝试使用该时区清理时间
    new Date().toLocaleString('en-US', { timeZone: timezone });
    返回 true；
  } catch (error) {
    返回 false；
  }
}

// 农历转换工具函数
const lunarCalendar = {
  // 农历数据 (1900-2100年)
  lunarInfo: [
    0x04bd8、0x04ae0、0x0a570、0x054d5、0x0d260、0x0d950、0x16554、0x056a0、0x09ad0、0x055d2、
    0x04ae0、0x0a5b6、0x0a4d0、0x0d250、0x1d255、0x0b540、0x0d6a0、0x0ada2、0x095b0、0x14977、
    0x04970、0x0a4b0、0x0b4b5、0x06a50、0x06d40、0x1ab54、0x02b60、0x09570、0x052f2、0x04970
    0x06566、0x0d4a0、0x0ea50、0x06e95、0x05ad0、0x02b60、0x186e3、0x092e0、0x1c8d7、0x0c950
    0x0d4a0、0x1d8a6、0x0b550、0x056a0、0x1a5b4、0x025d0、0x092d0、0x0d2b2、0x0a950、0x0b557、
    0x06ca0、0x0b550、0x15355、0x04da0、0x0a5b0、0x14573、0x052b0、0x0a9a8、0x0e950、0x06aa0
    0x0aea6、0x0ab50、0x04b60、0x0aae4、0x0a570、0x05260、0x0f263、0x0d950、0x05b57、0x056a0、
    0x096d0、0x04dd5、0x04ad0、0x0a4d0、0x0d4d4、0x0d250、0x0d558、0x0b540、0x0b6a0、0x195a6、
    0x095b0、0x049b0、0x0a974、0x0a4b0、0x0b27a、0x06a50、0x06d40、0x0af46、0x0ab60、0x09570、
    0x04af5、0x04970、0x064b0、0x074a3、0x0ea50、0x06b58、0x055c0、0x0ab60、0x096d5、0x092e0、
    0x0c960、0x0d954、0x0d4a0、0x0da50、0x07552、0x056a0、0x0abb7、0x025d0、0x092d0、0x0cab5
    0x0a950、0x0b4a0、0x0baa4、0x0ad50、0x055d9、0x04ba0、0x0a5b0、0x15176、0x052b0、0x0a930
    0x07954、0x06aa0、0x0ad50、0x05b52、0x04b60、0x0a6e6、0x0a4e0、0x0d260、0x0ea65、0x0d530、
    0x05aa0、0x076a3、0x096d0、0x04bd7、0x04ad0、0x0a4d0、0x1d0b6、0x0d250、0x0d520、0x0dd45、
    0x0b5a0、0x056d0、0x055b2、0x049b0、0x0a577、0x0a4b0、0x0aa50、0x1b255、0x06d20、0x0ada0
  ],

  // 天干地支
  干: ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸'],
  zhi: ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥'],

  // 农历月份
  月份: ['正', '二', '三', '四', '五', '六', '七', '八', '九', '十', '冬', '腊'],

  // 农历日期
  days: ['初一', '初二', '初三', '初四', '初五', '初六', '初七', '初八', '初九', '初十',
         '十一', '十二', '十三', '十四', '十五', '十六', '十七', '十八', '十九', '二十',
         '二十一', '二十二', '二十三', '二十四', '二十五', '二十六', '二十七', '二十八', '二十九', '三十'],

  // 获取农历年天数
  lunarYearDays: function(year) {
    令总和 = 348；
    for (let i = 0x8000; i > 0x8; i >>= 1) {
      sum += (this.lunarInfo[year - 1900] & i) ? 1 : 0;
    }
    返回总和 + this.leapDays(year)；
  },

  //获取闰月天数
  闰日：function(year) {
    如果 (this.leapMonth(year)) {
      return (this.lunarInfo[year - 1900] & 0x10000) ? 30 : 29;
    }
    返回 0；
  },

  // 获取闰月月份
  闰月：function(year) {
    返回 this.lunarInfo[year - 1900] & 0xf;
  },

  // 获取农历月天数
  monthDays: function(year, month) {
    return (this.lunarInfo[year - 1900] & (0x10000 >> month)) ? 30 : 29;
  },

  // 公历转农历
  solar2lunar: function(year, month, day) {
    如果（年份小于 1900 年或大于 2100 年）则返回 null；

    const baseDate = new Date(1900, 0, 31);
    const objDate = new Date(year, month - 1, day);
    //let offset = Math.floor((objDate - baseDate) / 86400000);
    let offset = Math.round((objDate - baseDate) / 86400000);


    let temp = 0;
    let lunarYear = 1900;

    for (lunarYear = 1900; lunarYear < 2101 && offset > 0; lunarYear++) {
      temp = this.lunarYearDays(lunarYear);
      偏移量 -= 温度；
    }

    如果（偏移量 < 0）{
      偏移量 += 温度；
      农历年--;
    }

    let lunarMonth = 1;
    let leap = this.leapMonth(lunarYear);
    let isLeap = false;

    for (lunarMonth = 1; lunarMonth < 13 && offset > 0; lunarMonth++) {
      如果（闰月 > 0 && 农历月份 === （闰月 + 1） && !isLeap）{
        --lunarMonth;
        isLeap = true;
        temp = this.leapDays(lunarYear);
      } 别的 {
        temp = this.monthDays(lunarYear, lunarMonth);
      }

      如果（是闰月且农历月份等于（闰月 + 1））isLeap = false;
      偏移量 -= 温度；
    }

    如果（偏移量 === 0 && 闰月 > 0 && 农历月份 === 闰月 + 1）{
      如果 (isLeap) {
        isLeap = false;
      } 别的 {
        isLeap = true;
        --lunarMonth;
      }
    }

    如果（偏移量 < 0）{
      偏移量 += 温度；
      --lunarMonth;
    }

    const lunarDay = offset + 1;

    // 生成农历字符串
    const ganIndex = (lunarYear - 4) % 10;
    const zhiIndex = (lunarYear - 4) % 12;
    constyearStr = this.gan[ganIndex] + this.zhi[zhiIndex] + '年';
    const MonthStr = (isLeap ? '闰' : '') + this.months[lunarMonth - 1] + '月';
    const dayStr = this.days[lunarDay - 1];

    返回 {
      年份：农历年，
      月份：农历月，
      日期：农历日，
      isLeap：isLeap，
      yearStr: yearStr,
      monthStr: monthStr，
      dayStr: dayStr，
      完整字符串：年份字符串 + 月份字符串 + 日期字符串
    };
  }
};

// 1.新增lunarBiz工具模块，支持农历周期加、农历转公历、农历距离天数
const lunarBiz = {
  // 农历加周期，返回新的农历数据对象
  addLunarPeriod(农历, periodValue, periodUnit) {
    let { year, month, day, isLeap } = lunar;
    如果 (periodUnit === 'year') {
      年份 += 时期值；
      const leap = lunarCalendar.leapMonth(year);
      如果（是闰月 && 闰月 === 月份）{
        isLeap = true;
      } 别的 {
        isLeap = false;
      }
    } else if (periodUnit === 'month') {
      let totalMonths = (year - 1900) * 12 + (month - 1) + periodValue;
      年份 = Math.floor(总月份 / 12) + 1900;
      月份 = (总月份 % 12) + 1;
      const leap = lunarCalendar.leapMonth(year);
      如果（是闰月 && 闰月 === 月份）{
        isLeap = true;
      } 别的 {
        isLeap = false;
      }
    } else if (periodUnit === 'day') {
      const solar = lunarBiz.lunar2solar(lunar);
      const date = new Date(solar.year, solar.month - 1, solar.day + periodValue);
      return lunarCalendar.solar2lunar(date.getFullYear(), date.getMonth() + 1, date.getDate());
    }
    let maxDay = isLeap
      ? lunarCalendar.leapDays(year)
      : lunarCalendar.monthDays(year, month);
    let targetDay = Math.min(day, maxDay);
    while (targetDay > 0) {
      let solar = lunarBiz.lunar2solar({ year, month, day: targetDay, isLeap });
      如果（太阳能）{
        返回 { year, month, day: targetDay, isLeap };
      }
      目标日期--;
    }
    返回 { 年，月，日，是否为闰年 }；
  },
  // 农历转公历（遍历法，适用1900-2100年）
  lunar2solar(lunar) {
    for (let y = lunar.year - 1; y <= lunar.year + 1; y++) {
      for (let m = 1; m <= 12; m++) {
        for (let d = 1; d <= 31; d++) {
          const date = new Date(y, m - 1, d);
          如果（日期的完整年份不是 y，月份加 1 不是 m，日期的日期不是 d），则继续；
          const l=lunarCalendar.solar2lunar(y, m, d);
          如果 （
            l &&
            l.year === 农历年 &&
            l.month === lunar.month &&
            l.day === 农历日 &&
            l.isLeap === lunar.isLeap
          ) {
            返回 { year: y, month: m, day: d };
          }
        }
      }
    }
    返回空值；
  },
  // 距离农历日期还有多少天
  daysToLunar(lunar) {
    const solar = lunarBiz.lunar2solar(lunar);
    const date = new Date(solar.year, solar.month - 1, solar.day);
    const now = new Date();
    返回 Math.ceil((date - now) / (1000 * 60 * 60 * 24));
  }
};

// 定义HTML模板
const loginPage = `
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>订阅管理系统</title>
  <link href="https://cdn.jsdelivr.net/npm/tailwindcss@2.2.19/dist/tailwind.min.css" rel="stylesheet">
  <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0-beta3/css/all.min.css" rel="stylesheet">
  <style>
    .login-container {
      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
      最小高度：100vh；
    }
    .login-box {
      背景滤镜：模糊(8px);
      background-color: rgba(255, 255, 255, 0.9);
      box-shadow: 0 10px 25px rgba(0, 0, 0, 0.15);
    }
    .btn-primary {
      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
      过渡：全部 0.3 秒；
    }
    .btn-primary:hover {
      transform: translateY(-2px);
      box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1);
    }
    .input-field {
      过渡：全部 0.3 秒；
      border: 1px solid #e2e8f0;
    }
    .input-field:focus {
      边框颜色：#667eea；
      box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.25);
    }
  </style>
</head>
<body class="login-container flex items-center justify-center">
  <div class="login-box p-8 rounded-xl w-full max-w-md">
    <div class="text-center mb-8">
      <h1 class="text-2xl font-bold text-gray-800"><i class="fas fa-calendar-check mr-2"></i>订阅管理系统</h1>
      <p class="text-gray-600 mt-2">登录管理您的提醒订阅</p>
    </div>
    
    <form id="loginForm" class="space-y-6">
      <div>
        <label for="username" class="block text-sm font-medium text-gray-700 mb-1">
          <i class="fas fa-user mr-2"></i>用户名
        </label>
        <input type="text" id="username" name="username" required
          class="input-field w-full px-4 py-3 rounded-lg text-gray-700 focus:outline-none">
      </div>
      
      <div>
        <label for="password" class="block text-sm font-medium text-gray-700 mb-1">
          <i class="fas fa-lock mr-2"></i>密码
        </label>
        <input type="password" id="password" name="password" required
          class="input-field w-full px-4 py-3 rounded-lg text-gray-700 focus:outline-none">
      </div>
      
      <button type="提交"
        class="btn-primary w-full py-3 rounded-lg text-white font-medium focus:outline-none">
        <i class="fas fa-sign-in-alt mr-2"></i>登录
      </button>
      
      <div id="errorMsg" class="text-red-500 text-center"></div>
    </form>
  </div>
  
  <script>
    document.getElementById('loginForm').addEventListener('submit', async (e) => {
      e.preventDefault();
      const username = document.getElementById('username').value;
      const password = document.getElementById('password').value;
      
      const button = e.target.querySelector('button');
      const OriginalContent = Button.innerHTML;
      button.innerHTML = '<i class="fas fa-spinner fa-spin mr-2"></i>登录中...';
      按钮已禁用 = true;
      
      尝试 {
        const response = await fetch('/api/login', {
          方法：'POST'，
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({ username, password })
        });
        
        const result = await response.json();
        
        如果 (结果成功) {
          window.location.href = '/admin';
        } 别的 {
          document.getElementById('errorMsg').textContent = result.message || '用户名或密码错误';
          按钮.innerHTML = 原始内容;
          按钮已禁用 = false;
        }
      } catch (error) {
        document.getElementById('errorMsg').textContent = '发生错误，请稍后再试';
        按钮.innerHTML = 原始内容;
        按钮已禁用 = false;
      }
    });
  </script>
</body>
</html>
`;

const adminPage = `
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>订阅管理系统</title>
  <link href="https://cdn.jsdelivr.net/npm/tailwindcss@2.2.19/dist/tailwind.min.css" rel="stylesheet">
  <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0-beta3/css/all.min.css" rel="stylesheet">
  <style>
    .btn-primary { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); transition: all 0.3s; }
    .btn-primary:hover { transform: translateY(-2px); box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1); }
    .btn-danger { background: linear-gradient(135deg, #f87171 0%, #dc2626 100%); transition: all 0.3s; }
    .btn-danger:hover { transform: translateY(-2px); box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1); }
    .btn-success { background: linear-gradient(135deg, #34d399 0%, #059669 100%); transition: all 0.3s; }
    .btn-success:hover { transform: translateY(-2px); box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1); }
    .btn-warning { background: linear-gradient(135deg, #fbbf24 0%, #d97706 100%); transition: all 0.3s; }
    .btn-warning:hover { transform: translateY(-2px); box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1); }
    .btn-info { background: linear-gradient(135deg, #3b82f6 0%, #60a5fa 100%); transition: all 0.3s; }
    .btn-info:hover { transform: translateY(-2px); box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1); }
    .table-container { box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06); }
    .modal-container { background-filter: blur(8px); }
    .readonly-input { background-color: #f8fafc; border-color: #e2e8f0; cursor: not-allowed; }
    .error-message { font-size: 0.875rem; margin-top: 0.25rem; display: none; }
    .error-message.show { display: block; }

    /* 通用悬浮提示优化 */
    .hover-container {
      位置：相对；
      宽度：100%；
    }
    .hover-text {
      最大宽度：100%；
      溢出：隐藏；
      文本溢出：省略号；
      空格：不换行；
      光标：指针；
      过渡：全部缓动 0.3 秒；
      显示：块；
    }
    .hover-text:hover { color: #3b82f6; }
    .hover-tooltip {
      位置：固定；
      z-index：9999；
      背景色：#1f2937；
      颜色：白色；
      内边距：10px 14px；
      圆角半径：8px；
      字体大小：0.875rem；
      最大宽度：320像素；
      换行：break-word；
      box-shadow: 0 10px 25px rgba(0, 0, 0, 0.2);
      不透明度：0；
      可见性：隐藏；
      过渡：全部缓动 0.3 秒；
      transform: translateY(-10px);
      空格：正常；
      指针事件：无；
      行高：1.4；
    }
    .hover-tooltip.show {
      不透明度：1；
      可见性：可见；
      变换：translateY(0);
    }
    .hover-tooltip::before {
      内容： '';
      位置：绝对定位；
      顶部：-6px；
      左侧：20像素；
      border-left: 6px solid transparent;
      border-right: 6px solid transparent;
      border-bottom: 6px solid #1f2937;
    }
    .hover-tooltip.tooltip-above::before {
      顶部：自动；
      底部：-6px；
      底部边框：无；
      border-top: 6px solid #1f2937;
    }

    /* 备注显示优化 */
    .notes-container {
      位置：相对；
      最大宽度：200像素；
      宽度：100%；
    }
    .notes-text {
      最大宽度：100%；
      溢出：隐藏；
      文本溢出：省略号；
      空格：不换行；
      光标：指针；
      过渡：全部缓动 0.3 秒；
      显示：块；
    }
    .notes-text:hover { color: #3b82f6; }
    .notes-tooltip {
      位置：固定；
      z-index：9999；
      背景色：#1f2937；
      颜色：白色；
      内边距：10px 14px；
      圆角半径：8px；
      字体大小：0.875rem；
      最大宽度：320像素；
      换行：break-word；
      box-shadow: 0 10px 25px rgba(0, 0, 0, 0.2);
      不透明度：0；
      可见性：隐藏；
      过渡：全部缓动 0.3 秒；
      transform: translateY(-10px);
      空格：正常；
      指针事件：无；
      行高：1.4；
    }
    .notes-tooltip.show {
      不透明度：1；
      可见性：可见；
      变换：translateY(0);
    }
    .notes-tooltip::before {
      内容： '';
      位置：绝对定位；
      顶部：-6px；
      左侧：20像素；
      border-left: 6px solid transparent;
      border-right: 6px solid transparent;
      border-bottom: 6px solid #1f2937;
    }
    .notes-tooltip.tooltip-above::before {
      顶部：自动；
      底部：-6px；
      底部边框：无；
      border-top: 6px solid #1f2937;
    }

    /* 农历显示样式 */
    .lunar-display {
      字体大小：0.75rem；
      颜色：#6366f1；
      margin-top: 2px;
      不透明度：0；
      transition: opacity 0.3s ease;
    }
    .lunar-display.show {
      不透明度：1；
    }
    /* 自定义日期选择器样式 */
    .hidden {
      显示：无！重要；
    }
    
    .custom-date-picker {
      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
      box-shadow: 0 10px 25px rgba(0, 0, 0, 0.15);
      圆角半径：12px；
      最小宽度：380像素；
    }
    
    .custom-date-picker .calendar-day {
      显示方式：flex；
      弯曲方向：柱；
      align-items: center;
      justify-content: center;
      宽度：48像素；
      高度：60像素；
      圆角半径：6px；
      光标：指针；
      过渡：全部缓动 0.2 秒；
      位置：相对；
      内边距：4px；
      字体大小：14px；
    }
    
    .custom-date-picker .calendar-day:hover {
      背景颜色：#e0e7ff；
      变换：缩放（1.05）；
    }
    
    .custom-date-picker .calendar-day.selected {
      背景颜色：#6366f1；
      颜色：白色；
      变换：缩放（1.1）；
      box-shadow: 0 2px 8px rgba(99, 102, 241, 0.3);
    }
    
    .custom-date-picker .calendar-day.today {
      背景颜色：#e0e7ff；
      颜色：#6366f1；
      字体粗细：600；
      border: 2px solid #6366f1;
    }
    
    .custom-date-picker .calendar-day.other-month {
      颜色：#d1d5db；
    }
    
    .custom-date-picker .calendar-day .lunar-text {
      字体大小：11像素；
      行高：1.2；
      margin-top: 3px;
      不透明度：0.85；
      文本对齐方式：居中；
      字体粗细：500；
    }
    
    .custom-date-picker .calendar-day.selected .lunar-text {
      颜色：rgba(255, 255, 255, 0.9);
    }
    
    .custom-date-picker .calendar-day.today .lunar-text {
      颜色：#6366f1；
    }
    
    /* 年份和年份选择器样式 */
    .month-option, .year-option {
      过渡：全部缓动 0.2 秒；
      border: 1px solid transparent;
    }
    
    .month-option:hover, .year-option:hover {
      background-color: #e0e7ff !important;
      边框颜色：#6366f1；
      颜色：#6366f1；
    }
    
    .month-option.selected, .year-option.selected {
      background-color: #6366f1 !important;
      颜色：白色；
      边框颜色：#6366f1；
    }
    
    .lunar-toggle {
      显示：内联弹性；
      align-items: center;
      margin-bottom: 8px;
      字体大小：0.875rem；
    }
    .lunar-toggle 输入[type="checkbox"] {
      右边距：6px；
    }

    /* 表格布局优化 */
    .table-container {
      宽度：100%；
      溢出：可见；
    }

    .table-container 表格 {
      表格布局：固定；
      宽度：100%；
    }

    /* 防止表单内容溢出 */
    .table-container td {
      溢出：隐藏；
      换行：break-word；
    }

    .truncate {
      溢出：隐藏；
      文本溢出：省略号；
      空格：不换行；
    }

    /* 响应式优化 */
    .responsive-table { table-layout: fixed; width: 100%; }
    .td-content-wrapper { word-wrap: break-word; white-space: normal; text-align: left; width: 100%; }
    .td-content-wrapper > * { text-align: left; } /* 将容器内的内容左对齐 */

    @media (max-width: 767px) {
      .table-container { overflow-x: initial; } /* 覆盖之前的设置 */
      .responsive-table thead { display: none; }
      .responsive-table tbody, .responsive-table tr, .responsive-table td { display: block; width: 100%; }
      .responsive-table tr { margin-bottom: 1.5rem; border: 1px solid #ddd; border-radius: 0.5rem; box-shadow: 0 2px 4px rgba(0,0,0,0.05); overflow: hidden; }
      .responsive-table td { display: flex; justify-content: flex-start; align-items: center; padding: 0.75rem 1rem; border-bottom: 1px solid #eee; }
      .responsive-table td:last-of-type { border-bottom: none; }
      .responsive-table td:before { content: attr(data-label); font-weight: 600; text-align: left; padding-right: 1rem; color: #374151; white-space: nowrap; }
      .action-buttons-wrapper { display: flex; flex-wrap: wrap; gap: 0.5rem; justify-content: flex-end; }
      
      .notes-container, .hover-container {
        max-width: 180px; /* 调整以适应新布局 */
        文本对齐方式：右对齐；
      }
      .td-content-wrapper .notes-text {
        文本对齐方式：右对齐；
      }
     }
    @media (max-width: 767px) {
      #systemTimeDisplay {
        显示：无！重要；
      }
    }
    @media (min-width: 768px) {
      .table-container {
        溢出：可见；
      }
      /* .td-content-wrapper 默认左对齐 */
    }

    /* 吐司样式 */
    .toast {
      position: fixed; top: 20px; right: 20px; padding: 12px 20px; border-radius: 8px;
      颜色：白色；字体粗细：500；z轴索引：1000；变换：translateX(400px)；
      transition: all 0.3s ease-in-out; box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
    }
    .toast.show { transform: translateX(0); }
    .toast.success { background-color: #10b981; }
    .toast.error { background-color: #ef4444; }
    .toast.info { background-color: #3b82f6; }
    .toast.warning { background-color: #f59e0b; }
  </style>
</head>
<body class="bg-gray-100 min-h-screen">
  <div id="toast-container"></div>

  <nav class="bg-white shadow-md">
    <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
      <div class="flex justify-between h-16">
        <div class="flex items-center">
          <i class="fas fa-calendar-check text-indigo-600 text-2xl mr-2"></i>
          <span class="font-bold text-xl text-gray-800">订阅管理系统</span>
          <span id="systemTimeDisplay" class="ml-4 text-base text-indigo-600 font-normal"></span>
        </div>
        <div class="flex items-center space-x-4">
          <a href="/admin" class="text-indigo-600 border-b-2 border-indigo-600 px-3 py-2 rounded-md text-sm font-medium">
            <i class="fas fa-list mr-1"></i>订阅列表
          </a>
          <a href="/admin/config" class="text-gray-700 hover:text-gray-900 px-3 py-2 rounded-md text-sm font-medium">
            <i class="fas fa-cog mr-1"></i>系统配置
          </a>
          <a href="/api/logout" class="text-gray-700 hover:text-gray-900 px-3 py-2 rounded-md text-sm font-medium">
            <i class="fas fa-sign-out-alt mr-1"></i>退出登录
          </a>
        </div>
      </div>
    </div>
  </nav>
  
  <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
    <div class="flex flex-col md:flex-row md:items-center md:justify-between gap-4 mb-6">
      <div>
        <h2 class="text-2xl font-bold text-gray-800">订阅列表</h2>
        <p class="text-sm text-gray-500 mt-1">使用搜索与分类快速定位订阅，开启农历显示可同步查看农历日期</p>
      </div>
      <div class="flex flex-col lg:flex-row lg:items-center lg:justify-between gap-4 w-full">
        <div class="flex flex-col sm:flex-row sm:items-center gap-3 w-full lg:flex-1 lg:max-w-2xl">
          <div class="relative flex-1 min-w-[200px] lg:max-w-md">
            <input type="text" id="searchKeyword" placeholder="搜索名称、类型或备注..." class="w-full pl-10 pr-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500">
            <span class="absolute inset-y-0 left-0 pl-3 flex items-center text-gray-400">
              <i class="fas fa-search"></i>
            </span>
          </div>
          <div class="sm:w-44 lg:w-40">
            <select id="categoryFilter" class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 bg-white">
              <option value="">全部分类</option>
            </select>
          </div>
        </div>
        <div class="flex items-center space-x-3 lg:space-x-4">
        <label class="lunar-toggle">
          <input type="checkbox" id="listShowLunar" class="form-checkbox h-4 w-4 text-indigo-600 shrink-0">
          <span class="text-gray-700">显示农历</span>
        </label>
        <button id="addSubscriptionBtn" class="btn-primary text-white px-4 py-2 rounded-md text-sm font-medium flex items-center shrink-0">
          <i class="fas fa-plus mr-2"></i>添加新订阅
        </button>
      </div>
      </div>
    </div>
    
    <div class="table-container bg-white rounded-lg overflow-hidden">
      <div class="overflow-x-auto">
        <table class="w-full divide-y divide-gray-200 responsive-table">
          <thead class="bg-gray-50">
            <tr>
              <th scope="col" class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider" style="width: 25%;">
                名称
              </th>
              <th scope="col" class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider" style="width: 15%;">
                类型
              </th>
              <th scope="col" class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider" style="width: 20%;">
                兑时间 <i class="fas fa-sort-up ml-1 text-indigo-500" title="按兑时间升序排列"></i>
              </th>
              <th scope="col" class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider" style="width: 15%;">
                提醒设置
              </th>
              <th scope="col" class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider" style="width: 10%;">
                状态
              </th>
              <th scope="col" class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider" style="width: 15%;">
                操作
              </th>
            </tr>
          </thead>
        <tbody id="subscriptionsBody" class="bg-white divide-y divide-gray-200">
        </tbody>
        </table>
      </div>
    </div>
  </div>

  <!- 制作-/编辑订阅的模态框 -->
  <div id="subscriptionModal" class="fixed inset-0 bg-gray-600 bg-opacity-50 modal-container hidden flex items-center justify-center z-50">
    <div class="bg-white rounded-lg shadow-xl max-w-2xl w-full mx-4 max-h-screen overflow-y-auto">
      <div class="bg-gray-50 px-6 py-4 border-b border-gray-200 rounded-t-lg">
        <div class="flex items-center justify-between">
          <h3 id="modalTitle" class="text-lg font-medium text-gray-900">添加新订阅</h3>
          <button id="closeModal" class="text-gray-400 hover:text-gray-600">
            <i class="fas fa-times text-xl"></i>
          </button>
        </div>
      </div>
      
      <form id="subscriptionForm" class="p-6 space-y-6">
        <input type="hidden" id="subscriptionId">
        
        <div class="grid grid-cols-1 md:grid-cols-3 gap-6">
          <div>
            <label for="name" class="block text-sm font-medium text-gray-700 mb-1">订阅名称 *</label>
            <input type="text" id="name" required
              class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500">
            <div class="error-message text-red-500" data-for="reminderValue"></div>
          </div>
          
          <div>
            <label for="customType" class="block text-sm font-medium text-gray-700 mb-1">订阅类型</label>
            <input type="text" id="customType" placeholder="例如：流媒体、云服务、软件、生日等"
              class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500">
            <div class="error-message text-red-500"></div>
          </div>

          <div>
            <label for="category" class="block text-sm font-medium text-gray-700 mb-1">分类标签</label>
            <input type="text" id="category" placeholder="例如：个人、家庭、公司"
              class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500">
            <p class="mt-1 text-xs text-gray-500">可输入多个标签并使用“/”分隔，根据筛选和统计</p>
            <div class="error-message text-red-500"></div>
          </div>
        </div>
        
        <div class="mb-4 flex items-center space-x-6">
          <label class="lunar-toggle">
            <input type="checkbox" id="showLunar" class="form-checkbox h-4 w-4 text-indigo-600">
            <span class="text-gray-700">显示农历日期</span>
          </label>
          <label class="lunar-toggle">
            <input type="checkbox" id="useLunar" class="form-checkbox h-4 w-4 text-indigo-600">
            <span class="text-gray-700">周期按农历</span>
          </label>
        </div>

                <div class="grid grid-cols-1 md:grid-cols-4 gap-4">
          <div class="md:col-span-2">
            <label for="startDate" class="block text-sm font-medium text-gray-700 mb-1">开始日期</label>
            <div class="relative">
              <input type="text" id="startDate"
                class="w-full px-3 py-2 pr-10 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500"
                placeholder="YYYY-MM-DD 或点击右侧图标选择">
              <div class="absolute inset-y-0 right-0 flex items-center pr-3 pointer-events-none">
                <i class="fas fa-calendar text-gray-400"></i>
              </div>
                              <div id="startDatePicker" class="custom-date-picker hidden absolute top-full left-0 z-50 bg-white border border-gray-300 rounded-md shadow-lg p-6 min-w-[380px]">
                  <div class="flex justify-between items-center mb-4">
                    <button type="button" id="startDatePrevMonth" class="text-gray-600 hover:text-gray-800">
                      <i class="fas fa-chevron-left"></i>
                    </button>
                    <div class="flex items-center space-x-2">
                      <span id="startDateMonth" class="font-medium text-gray-900 cursor-pointer hover:text-indigo-600">1月</span>
                      <span class="text-gray-400">|</span>
                      <span id="startDateYear" class="font-medium text-gray-900 cursor-pointer hover:text-indigo-600">2024</span>
                    </div>
                    <button type="button" id="startDateNextMonth" class="text-gray-600 hover:text-gray-800">
                      <i class="fas fa-chevron-right"></i>
                    </button>
                  </div>
                  
                  <!-- 月份选择器 -->
                  <div id="startDateMonthPicker" class="hidden mb-4">
                    <div class="flex justify-between items-center mb-3">
                      <span class="font-medium text-gray-900">选择月份</span>
                      <button type="button" id="startDateBackToCalendar" class="text-gray-600 hover:text-gray-800">
                        <i class="fas fa-times"></i>
                      </button>
                    </div>
                    <div class="grid grid-cols-3 gap-2">
                      <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="0">1月</button>
                      <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="1">2月</button>
                      <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="2">3月</button>
                      <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="3">4月</button>
                      <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="4">5月</button>
                      <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="5">6月</button>
                      <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="6">7月</button>
                      <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="7">8月</button>
                      <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="8">9月</button>
                      <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="9">10月</button>
                      <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="10">11月</button>
                      <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="11">12月</button>
                    </div>
                  </div>
                  
                  <!-- 年份选择器 -->
                  <div id="startDateYearPicker" class="hidden mb-4">
                    <div class="flex justify-between items-center mb-3">
                      <span class="font-medium text-gray-900">选择年份</span>
                      <button type="button" id="startDateBackToCalendarFromYear" class="text-gray-600 hover:text-gray-800">
                        <i class="fas fa-times"></i>
                      </button>
                    </div>
                    <div class="flex justify-between items-center mb-3">
                      <button type="button" id="startDatePrevYearDecade" class="text-gray-600 hover:text-gray-800">
                        <i class="fas fa-chevron-left"></i>
                      </button>
                      <span id="startDateYearRange" class="font-medium text-gray-900">2020-2029</span>
                      <button type="button" id="startDateNextYearDecade" class="text-gray-600 hover:text-gray-800">
                        <i class="fas fa-chevron-right"></i>
                      </button>
                    </div>
                    <div id="startDateYearGrid" class="grid grid-cols-3 gap-2">
                      <!-- 年份按钮将通过JavaScript动态生成 -->
                    </div>
                  </div>
                  
                  <div class="grid grid-cols-7 gap-2 mb-3">
                    <div class="text-center text-sm font-semibold text-gray-600 py-2">日</div>
                    <div class="text-center text-sm font-semibold text-gray-600 py-2">一</div>
                    <div class="text-center text-sm font-semibold text-gray-600 py-2">二</div>
                    <div class="text-center text-sm font-semibold text-gray-600 py-2">三</div>
                    <div class="text-center text-sm font-semibold text-gray-600 py-2">四</div>
                    <div class="text-center text-sm font-semibold text-gray-600 py-2">五</div>
                    <div class="text-center text-sm font-semibold text-gray-600 py-2">六</div>
                  </div>
                  <div id="startDateCalendar" class="grid grid-cols-7 gap-2"></div>
                  
                  <!-- 回到今天按钮 -->
                  <div class="mt-4 pt-3 border-t border-gray-200">
                    <button type="button" id="startDateGoToToday" class="w-full px-3 py-2 text-sm text-indigo-600 hover:bg-indigo-50 rounded-md">
                      <i class="fas fa-calendar-day mr-2"></i>回到今天
                    </button>
                  </div>
                </div>
            </div>
            <div id="startDateLunar" class="lunar-display"></div>
            <div class="error-message text-red-500"></div>
          </div>
          
          <div>
            <label for="periodValue" class="block text-sm font-medium text-gray-700 mb-1">周期数值 *</label>
            <input type="number" id="periodValue" min="1" value="1" required
              class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500">
            <div class="error-message text-red-500"></div>
          </div>
          
          <div>
            <label for="periodUnit" class="block text-sm font-medium text-gray-700 mb-1">周期单位 *</label>
            <select id="periodUnit" 必填
              class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500">
              <option value="day">天</option>
              <option value="month" selected>月</option>
              <option value="year">年</option>
            </select>
            <div class="error-message text-red-500"></div>
          </div>
        </div>
        
        <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
          <div>
            <label for="expiryDate" class="block text-sm font-medium text-gray-700 mb-1">暴力日期 *</label>
            <div class="relative">
              <input type="text" id="expiryDate" required
                class="w-full px-3 py-2 pr-10 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500"
                placeholder="YYYY-MM-DD 或点击右侧图标选择">
              <div class="absolute inset-y-0 right-0 flex items-center pr-3 pointer-events-none">
                <i class="fas fa-calendar text-gray-400"></i>
              </div>
              <div id="expiryDatePicker" class="custom-date-picker hidden absolute top-full left-0 z-50 bg-white border border-gray-300 rounded-md shadow-lg p-6 min-w-[380px]">
                <div class="flex justify-between items-center mb-4">
                  <button type="button" id="expiryDatePrevMonth" class="text-gray-600 hover:text-gray-800">
                    <i class="fas fa-chevron-left"></i>
                  </button>
                  <div class="flex items-center space-x-2">
                    <span id="expiryDateMonth" class="font-medium text-gray-900 cursor-pointer hover:text-indigo-600">1月</span>
                    <span class="text-gray-400">|</span>
                    <span id="expiryDateYear" class="font-medium text-gray-900 cursor-pointer hover:text-indigo-600">2024</span>
                  </div>
                  <button type="button" id="expiryDateNextMonth" class="text-gray-600 hover:text-gray-800">
                    <i class="fas fa-chevron-right"></i>
                  </button>
                </div>
                
                <!-- 月份选择器 -->
                <div id="expiryDateMonthPicker" class="hidden mb-4">
                  <div class="flex justify-between items-center mb-3">
                    <span class="font-medium text-gray-900">选择月份</span>
                    <button type="button" id="expiryDateBackToCalendar" class="text-gray-600 hover:text-gray-800">
                      <i class="fas fa-times"></i>
                    </button>
                  </div>
                  <div class="grid grid-cols-3 gap-2">
                    <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="0">1月</button>
                    <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="1">2月</button>
                    <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="2">3月</button>
                    <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="3">4月</button>
                    <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="4">5月</button>
                    <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="5">6月</button>
                    <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="6">7月</button>
                    <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="7">8月</button>
                    <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="8">9月</button>
                    <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="9">10月</button>
                    <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="10">11月</button>
                    <button type="button" class="month-option px-3 py-2 text-sm rounded hover:bg-gray-100" data-month="11">12月</button>
                  </div>
                </div>
                
                <!-- 年份选择器 -->
                <div id="expiryDateYearPicker" class="hidden mb-4">
                  <div class="flex justify-between items-center mb-3">
                    <span class="font-medium text-gray-900">选择年份</span>
                    <button type="button" id="expiryDateBackToCalendarFromYear" class="text-gray-600 hover:text-gray-800">
                      <i class="fas fa-times"></i>
                    </button>
                  </div>
                  <div class="flex justify-between items-center mb-3">
                    <button type="button" id="expiryDatePrevYearDecade" class="text-gray-600 hover:text-gray-800">
                      <i class="fas fa-chevron-left"></i>
                    </button>
                    <span id="expiryDateYearRange" class="font-medium text-gray-900">2020-2029</span>
                    <button type="button" id="expiryDateNextYearDecade" class="text-gray-600 hover:text-gray-800">
                      <i class="fas fa-chevron-right"></i>
                    </button>
                  </div>
                  <div id="expiryDateYearGrid" class="grid grid-cols-3 gap-2">
                    <!-- 年份按钮将通过JavaScript动态生成 -->
                  </div>
                </div>
                
                <div class="grid grid-cols-7 gap-2 mb-3">
                  <div class="text-center text-sm font-semibold text-gray-600 py-2">日</div>
                  <div class="text-center text-sm font-semibold text-gray-600 py-2">一</div>
                  <div class="text-center text-sm font-semibold text-gray-600 py-2">二</div>
                  <div class="text-center text-sm font-semibold text-gray-600 py-2">三</div>
                  <div class="text-center text-sm font-semibold text-gray-600 py-2">四</div>
                  <div class="text-center text-sm font-semibold text-gray-600 py-2">五</div>
                  <div class="text-center text-sm font-semibold text-gray-600 py-2">六</div>
                </div>
                <div id="expiryDateCalendar" class="grid grid-cols-7 gap-2"></div>
                
                <!-- 回到今天按钮 -->
                <div class="mt-4 pt-3 border-t border-gray-200">
                  <button type="button" id="expiryDateGoToToday" class="w-full px-3 py-2 text-sm text-indigo-600 hover:bg-indigo-50 rounded-md">
                    <i class="fas fa-calendar-day mr-2"></i>回到今天
                  </button>
                </div>
              </div>
            </div>
            <div id="expiryDateLunar" class="lunar-display"></div>
            <div class="error-message text-red-500"></div>
            <div class="flex justify-end mt-2">
              <button type="button" id="calculateExpiryBtn"
                class="btn-primary text-white px-4 py-2 rounded-md text-sm font-medium whitespace-nowrap">
                <i class="fas fa-calculator mr-2"></i>自动计算变量日期
              </button>
            </div>
          </div>
        </div>
        
        <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
          <div>
            <label for="reminderValue" class="block text-sm font-medium text-gray-700 mb-1">提醒提前量</label>
            <div class="flex space-x-3">
              <input type="number" id="reminderValue" min="0" value="7"
                class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500">
              <select id="reminderUnit"
                class="w-32 px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 bg-white">
                <option value="day" selected>天</option>
                <option value="hour">小时</option>
              </select>
            </div>
            <p class="text-xs text-gray-500 mt-1">0 = 仅在定时任务提醒；选择“小时”需要将 Worker 定时任务调整为级执行</p>
            <div class="error-message text-red-500"></div>
          </div>
          
          <div>
            <label class="block text-sm font-medium text-gray-700 mb-3">选项设置</label>
            <div class="space-y-2">
              <label class="inline-flex items-center">
                <input type="checkbox" id="isActive" checked
                  class="form-checkbox h-4 w-4 text-indigo-600 rounded border-gray-300 focus:ring-indigo-500">
                <span class="ml-2 text-sm text-gray-700">订阅</span>
              </label>
              <label class="inline-flex items-center">
                <input type="checkbox" id="autoRenew" checked
                  class="form-checkbox h-4 w-4 text-indigo-600 rounded border-gray-300 focus:ring-indigo-500">
                <span class="ml-2 text-sm text-gray-700">自动续订</span>
              </label>
            </div>
          </div>
        </div>
        
        <div>
          <label for="notes" class="block text-sm font-medium text-gray-700 mb-1">备注</label>
          <textarea id="notes" rows="3" placeholder="可添加相关备注信息..."
            class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500"></textarea>
          <div class="error-message text-red-500"></div>
        </div>
        
        <div class="flex justify-end space-x-3 pt-4 border-t border-gray-200">
          <button type="button" id="cancelBtn"
            class="px-4 py-2 border border-gray-300 rounded-md text-sm font-medium text-gray-700 hover:bg-gray-50">
            取消
          </button>
          <button type="提交"
            class="btn-primary text-white px-4 py-2 rounded-md text-sm font-medium">
            <i class="fas fa-save mr-2"></i>保存
          </button>
        </div>
      </form>
    </div>
  </div>

  <script>
    // 兼容性函数 - 保持原有接口
    function formatBeijingTime(date = new Date(), format = 'full') {
      尝试 {
        const timezone = 'Asia/Shanghai';
        const dateObj = new Date(date);
        
        如果 (format === 'date') {
          返回 dateObj.toLocaleDateString('zh-CN', {
            时区：时区，
            年份：'数字'，
            月份：两位数，
            日期：两位数
          });
        } else if (format === 'datetime') {
          返回 dateObj.toLocaleString('zh-CN', {
            时区：时区，
            年份：'数字'，
            月份：两位数，
            日期：两位数
            小时：两位数，
            分钟：两位数，
            第二个：'两位数'
          });
        } 别的 {
          // 完整格式
          返回 dateObj.toLocaleString('zh-CN', {
            时区：时区
          });
        }
      } catch (error) {
        console.error('时间整理错误: ' + error.message);
        返回新的 Date(date).toISOString();
      }
    }

    // 农历转换工具函数 - 移植版本
    const lunarCalendar = {
      // 农历数据 (1900-2100年)
      lunarInfo: [
        0x04bd8、0x04ae0、0x0a570、0x054d5、0x0d260、0x0d950、0x16554、0x056a0、0x09ad0、0x055d2、
        0x04ae0、0x0a5b6、0x0a4d0、0x0d250、0x1d255、0x0b540、0x0d6a0、0x0ada2、0x095b0、0x14977、
        0x04970、0x0a4b0、0x0b4b5、0x06a50、0x06d40、0x1ab54、0x02b60、0x09570、0x052f2、0x04970
        0x06566、0x0d4a0、0x0ea50、0x06e95、0x05ad0、0x02b60、0x186e3、0x092e0、0x1c8d7、0x0c950
        0x0d4a0、0x1d8a6、0x0b550、0x056a0、0x1a5b4、0x025d0、0x092d0、0x0d2b2、0x0a950、0x0b557、
        0x06ca0、0x0b550、0x15355、0x04da0、0x0a5b0、0x14573、0x052b0、0x0a9a8、0x0e950、0x06aa0
        0x0aea6、0x0ab50、0x04b60、0x0aae4、0x0a570、0x05260、0x0f263、0x0d950、0x05b57、0x056a0、
        0x096d0、0x04dd5、0x04ad0、0x0a4d0、0x0d4d4、0x0d250、0x0d558、0x0b540、0x0b6a0、0x195a6、
        0x095b0、0x049b0、0x0a974、0x0a4b0、0x0b27a、0x06a50、0x06d40、0x0af46、0x0ab60、0x09570、
        0x04af5、0x04970、0x064b0、0x074a3、0x0ea50、0x06b58、0x055c0、0x0ab60、0x096d5、0x092e0、
        0x0c960、0x0d954、0x0d4a0、0x0da50、0x07552、0x056a0、0x0abb7、0x025d0、0x092d0、0x0cab5
        0x0a950、0x0b4a0、0x0baa4、0x0ad50、0x055d9、0x04ba0、0x0a5b0、0x15176、0x052b0、0x0a930
        0x07954、0x06aa0、0x0ad50、0x05b52、0x04b60、0x0a6e6、0x0a4e0、0x0d260、0x0ea65、0x0d530、
        0x05aa0、0x076a3、0x096d0、0x04bd7、0x04ad0、0x0a4d0、0x1d0b6、0x0d250、0x0d520、0x0dd45、
        0x0b5a0、0x056d0、0x055b2、0x049b0、0x0a577、0x0a4b0、0x0aa50、0x1b255、0x06d20、0x0ada0
      ],

      // 天干地支
      干: ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸'],
      zhi: ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥'],

      // 农历月份
      月份: ['正', '二', '三', '四', '五', '六', '七', '八', '九', '十', '冬', '腊'],

      // 农历日期
      days: ['初一', '初二', '初三', '初四', '初五', '初六', '初七', '初八', '初九', '初十',
             '十一', '十二', '十三', '十四', '十五', '十六', '十七', '十八', '十九', '二十',
             '二十一', '二十二', '二十三', '二十四', '二十五', '二十六', '二十七', '二十八', '二十九', '三十'],

      // 获取农历年天数
      lunarYearDays: function(year) {
        令总和 = 348；
        for (let i = 0x8000; i > 0x8; i >>= 1) {
          sum += (this.lunarInfo[year - 1900] & i) ? 1 : 0;
        }
        返回总和 + this.leapDays(year)；
      },

      //获取闰月天数
      闰日：function(year) {
        如果 (this.leapMonth(year)) {
          return (this.lunarInfo[year - 1900] & 0x10000) ? 30 : 29;
        }
        返回 0；
      },

      // 获取闰月月份
      闰月：function(year) {
        返回 this.lunarInfo[year - 1900] & 0xf;
      },

      // 获取农历月天数
      monthDays: function(year, month) {
        return (this.lunarInfo[year - 1900] & (0x10000 >> month)) ? 30 : 29;
      },

      // 公历转农历
      solar2lunar: function(year, month, day) {
        如果（年份小于 1900 年或大于 2100 年）则返回 null；

        const baseDate = new Date(1900, 0, 31);
        const objDate = new Date(year, month - 1, day);
        //let offset = Math.floor((objDate - baseDate) / 86400000);
        let offset = Math.round((objDate - baseDate) / 86400000);


        let temp = 0;
        let lunarYear = 1900;

        for (lunarYear = 1900; lunarYear < 2101 && offset > 0; lunarYear++) {
          temp = this.lunarYearDays(lunarYear);
          偏移量 -= 温度；
        }

        如果（偏移量 < 0）{
          偏移量 += 温度；
          农历年--;
        }

        let lunarMonth = 1;
        let leap = this.leapMonth(lunarYear);
        let isLeap = false;

        for (lunarMonth = 1; lunarMonth < 13 && offset > 0; lunarMonth++) {
          如果（闰月 > 0 && 农历月份 === （闰月 + 1） && !isLeap）{
            --lunarMonth;
            isLeap = true;
            temp = this.leapDays(lunarYear);
          } 别的 {
            temp = this.monthDays(lunarYear, lunarMonth);
          }

          如果（是闰月且农历月份等于（闰月 + 1））isLeap = false;
          偏移量 -= 温度；
        }

        如果（偏移量 === 0 && 闰月 > 0 && 农历月份 === 闰月 + 1）{
          如果 (isLeap) {
            isLeap = false;
          } 别的 {
            isLeap = true;
            --lunarMonth;
          }
        }

        如果（偏移量 < 0）{
          偏移量 += 温度；
          --lunarMonth;
        }

        const lunarDay = offset + 1;

        // 生成农历字符串
        const ganIndex = (lunarYear - 4) % 10;
        const zhiIndex = (lunarYear - 4) % 12;
        constyearStr = this.gan[ganIndex] + this.zhi[zhiIndex] + '年';
        const MonthStr = (isLeap ? '闰' : '') + this.months[lunarMonth - 1] + '月';
        const dayStr = this.days[lunarDay - 1];

        返回 {
          年份：农历年
          月份：农历月，
          日期：农历日，
          isLeap：isLeap，
          yearStr: yearStr,
          monthStr: monthStr，
          dayStr: dayStr，
          完整字符串：年份字符串 + 月份字符串 + 日期字符串
        };
      }
    };
	

// 新增修改，农历转公历（简化，适用1900-2100年）
函数 lunar2solar(lunar) {
  for (let y = lunar.year - 1; y <= lunar.year + 1; y++) {
    for (let m = 1; m <= 12; m++) {
      for (let d = 1; d <= 31; d++) {
        const date = new Date(y, m - 1, d);
        如果（日期的完整年份不是 y，月份加 1 不是 m，日期的日期不是 d），则继续；
        const l=lunarCalendar.solar2lunar(y, m, d);
        如果 （
          l &&
          l.year === 农历年 &&
          l.month === lunar.month &&
          l.day === 农历日 &&
          l.isLeap === lunar.isLeap
        ) {
          返回 { year: y, month: m, day: d };
        }
      }
    }
  }
  返回空值；
}

// 新增修改，农历加周期，前期版本
function addLunarPeriod(lunar, periodValue, periodUnit) {
  let { year, month, day, isLeap } = lunar;
  如果 (periodUnit === 'year') {
    年份 += 时期值；
    const leap = lunarCalendar.leapMonth(year);
    如果（是闰月 && 闰月 === 月份）{
      isLeap = true;
    } 别的 {
      isLeap = false;
    }
  } else if (periodUnit === 'month') {
    let totalMonths = (year - 1900) * 12 + (month - 1) + periodValue;
    年份 = Math.floor(总月份 / 12) + 1900;
    月份 = (总月份 % 12) + 1;
    const leap = lunarCalendar.leapMonth(year);
    如果（是闰月 && 闰月 === 月份）{
      isLeap = true;
    } 别的 {
      isLeap = false;
    }
  } else if (periodUnit === 'day') {
    const solar = lunar2solar(lunar);
    const date = new Date(solar.year, solar.month - 1, solar.day + periodValue);
    return lunarCalendar.solar2lunar(date.getFullYear(), date.getMonth() + 1, date.getDate());
  }
  let maxDay = isLeap
    ? lunarCalendar.leapDays(year)
    : lunarCalendar.monthDays(year, month);
  let targetDay = Math.min(day, maxDay);
  while (targetDay > 0) {
    let solar = lunar2solar({ year, month, day: targetDay, isLeap });
    如果（太阳能）{
      返回 { year, month, day: targetDay, isLeap };
    }
    目标日期--;
  }
  返回 { 年，月，日，是否为闰年 }；
}

// 传入lunarBiz对象的版本
const lunarBiz = {
  // 农历加周期，返回新的农历数据对象
  addLunarPeriod(农历, periodValue, periodUnit) {
    返回 addLunarPeriod(lunar, periodValue, periodUnit);
  },
  // 农历转公历（遍历法，适用1900-2100年）
  lunar2solar(lunar) {
    返回 lunar2solar(lunar);
  },
  // 距离农历日期还有多少天
  daysToLunar(lunar) {
    const solar = lunarBiz.lunar2solar(lunar);
    const date = new Date(solar.year, solar.month - 1, solar.day);
    const now = new Date();
    返回 Math.ceil((date - now) / (1000 * 60 * 60 * 24));
  }
};



    // 农历显示相关函数
    function updateLunarDisplay(dateInputId, lunarDisplayId) {
      const dateInput = document.getElementById(dateInputId);
      const lunarDisplay = document.getElementById(lunarDisplayId);
      const showLunar = document.getElementById('showLunar');

      如果 (!dateInput || !lunarDisplay) {
        返回;
      }

      如果 (!dateInput.value || !showLunar || !showLunar.checked) {
        lunarDisplay.classList.remove('show');
        返回;
      }

      const date = new Date(dateInput.value);
      const lunar = lunarCalendar.solar2lunar(date.getFullYear(), date.getMonth() + 1, date.getDate());

      如果（月球）{
        月球显示.textContent = '农历：' + 月球.fullStr;
        lunarDisplay.classList.add('show');
      } 别的 {
        lunarDisplay.classList.remove('show');
      }
    }

    function toggleLunarDisplay() {
      const showLunar = document.getElementById('showLunar');
      如果 (!showLunar) {
        返回;
      }
      
      updateLunarDisplay('startDate', 'startDateLunar');
      updateLunarDisplay('expiryDate', 'expiryDateLunar');

      // 保存用户偏好
      localStorage.setItem('showLunar', showLunar.checked);
    }

    function loadLunarPreference() {
      const showLunar = document.getElementById('showLunar');
      如果 (!showLunar) {
        返回;
      }
      
      const saved = localStorage.getItem('showLunar');
      如果 (已保存 !== null) {
        showLunar.checked = saved === 'true';
      } 别的 {
        showLunar.checked = true; //默认显示
      }
      切换月球显示();
    }

    function handleListLunarToggle() {
      const listShowLunar = document.getElementById('listShowLunar');
      // 保存用户偏好
      localStorage.setItem('showLunar', listShowLunar.checked);
      // 重新加载订阅列表以应用农历显示设置
      renderSubscriptionTable();
    }

    function showToast(message, type = 'success', duration = 3000) {
      const container = document.getElementById('toast-container');
      const toast = document.createElement('div');
      toast.className = 'toast ' + type;
      
      const icon = type === 'success' ? 'check-circle' :
                   type === 'error' ? '感叹号' :
                   type === 'warning' ? 'exclamation-triangle' : 'info-circle';
      
      toast.innerHTML = '<div class="flex items-center"><i class="fas fa-' + icon + ' mr-2"></i><span>' + message + '</span></div>';
      
      container.appendChild(toast);
      setTimeout(() => toast.classList.add('show'), 100);
      setTimeout(() => {
        toast.classList.remove('show');
        setTimeout(() => {
          如果（容器包含（toast））{
            container.removeChild(toast);
          }
        }, 300);
      }， 期间）;
    }

    function showFieldError(fieldId, message) {
      const field = document.getElementById(fieldId);
      let errorDiv = field.parentElement ? field.parentElement.querySelector('.error-message') : null;
      如果 (!errorDiv) {
        errorDiv = document.querySelector('.error-message[data-for="' + fieldId + '"]');
      }
      如果 (errorDiv) {
        errorDiv.textContent = 消息；
        errorDiv.classList.add('show');
        field.classList.add('border-red-500');
      }
    }

    function clearFieldErrors() {
      document.querySelectorAll('.error-message').forEach(el => {
        el.classList.remove('show');
        el.textContent = '';
      });
      document.querySelectorAll('.border-red-500').forEach(el => {
        el.classList.remove('border-red-500');
      });
    }

    function validateForm() {
      清除字段错误();
      let isValid = true;

      const name = document.getElementById('name').value.trim();
      如果 (!name) {
        showFieldError('name', '请输入订阅名称');
        isValid = false;
      }

      const periodValue = document.getElementById('periodValue').value;
      如果 (!periodValue || periodValue < 1) {
        showFieldError('periodValue', '周期数值必须大于0');
        isValid = false;
      }

      const expiryDate = document.getElementById('expiryDate').value;
      如果 (!expiryDate) {
        showFieldError('expiryDate', '请选择日期');
        isValid = false;
      }

      const reminderValueField = document.getElementById('reminderValue');
      const reminderValue = reminderValueField.value;
      如果 (reminderValue === '' || Number(reminderValue) < 0) {
        showFieldError('reminderValue', '提醒值不能为负数');
        isValid = false;
      }

      返回 isValid；
    }

    // 创建带悬浮提示的文本元素
    function createHoverText(text, maxLength = 30, className = 'text-sm text-gray-900') {
      如果 (!text || text.length <= maxLength) {
        return '<div class="' + className + '">' + text + '</div>';
      }

      const truncated = text.substring(0, maxLength) + '...';
      返回'<div class="hover-container">' +
        '<div class="hover-text ' + className + '" data-full-text="' + text.replace(/"/g, '"') + '">' +
          截断 +
        '</div>' +
        '<div class="hover-tooltip"></div>' +
      '</div>';
    }

    const categorySeparator = /[\/,，\s]+/;
    let subscriptionsCache = [];
    let searchDebounceTimer = null;

    function normalizeCategoryTokens(category = '') {
      返回类别
        .split(categorySeparator)
        .map(token => token.trim())
        .filter(token => token.length > 0);
    }

    function populateCategoryFilter(subscriptions) {
      const select = document.getElementById('categoryFilter');
      如果 (!select) {
        返回;
      }

      const previousValue = select.value;
      const categories = new Set();

      (subscriptions || []).forEach(subscription => {
        normalizeCategoryTokens(subscription.category).forEach(token => categories.add(token));
      });

      const sorted = Array.from(categories).sort((a, b) => a.localeCompare(b, 'zh-CN'));
      select.innerHTML = '';

      const defaultOption = document.createElement('option');
      defaultOption.value = '';
      defaultOption.textContent = '全部分类';
      select.appendChild(defaultOption);

      sorted.forEach(cat => {
        const option = document.createElement('option');
        option.value = cat;
        option.textContent = cat;
        select.appendChild(option);
      });

      如果 (previousValue && sorted.map(item => item.toLowerCase()).includes(previousValue.toLowerCase())) {
        select.value = previousValue;
      } 别的 {
        select.value = '';
      }
    }

    function getReminderSettings(subscription) {
      const fallbackDays = subscription.reminderDays !== undefined ? subscription.reminderDays : 7;
      let unit = subscription.reminderUnit || '';
      let value = subscription.reminderValue ;

      如果 (unit !== 'hour') {
        单位 = '天'；
      }

      如果 (unit === 'hour' && (value === undefined || value === null || isNaN(value))) {
        value = subscription.reminderHours !== undefined ? subscription.reminderHours : 0;
      }

      如果 (value === undefined || value === null || isNaN(value)) {
        值 = fallbackDays；
      }

      value = Number(value);

      返回 {
        单元，
        价值，
        显示文本：单位 === '小时' ？ '提前' + value + '小时' : '提前' + value + '天'
      };
    }

    function attachHoverListeners() {
      function positionTooltip(element, tooltip) {
        const rect = element.getBoundingClientRect();
        const tooltipHeight = 100;
        const viewportHeight = window.innerHeight;
        const scrollTop = window.pageYOffset || document.documentElement.scrollTop;

        let top = rect.bottom + scrollTop + 8;
        let left = rect.left;

        如果 (rect.bottom + tooltipHeight > viewportHeight) {
          top = rect.top + scrollTop - tooltipHeight - 8;
          tooltip.style.transform = 'translateY(10px)';
          tooltip.classList.add('tooltip-above');
        } 别的 {
          tooltip.style.transform = 'translateY(-10px)';
          tooltip.classList.remove('tooltip-above');
        }

        const maxLeft = window.innerWidth - 320 - 20;
        如果（左侧 > maxLeft）{
          左侧 = 最大左侧；
        }

        tooltip.style.left = left + 'px';
        tooltip.style.top = top + 'px';
      }

      document.querySelectorAll('.notes-text').forEach(notesElement => {
        const fullNotes = notesElement.getAttribute('data-full-notes');
        const tooltip = notesElement.parentElement.querySelector('.notes-tooltip');

        如果（完整笔记 && 工具提示）{
          notesElement.addEventListener('mouseenter', () => {
            工具提示.textContent = fullNotes;
            positionTooltip(notesElement, tooltip);
            tooltip.classList.add('显示');
          });

          notesElement.addEventListener('mouseleave', () => {
            tooltip.classList.remove('显示');
          });

          window.addEventListener('scroll', () => {
            如果 (tooltip.classList.contains('show')) {
              tooltip.classList.remove('显示');
            }
          }, { passive: true });
        }
      });

      document.querySelectorAll('.hover-text').forEach(hoverElement => {
        const fullText = hideElement.getAttribute('data-full-text');
        const tooltip = hoverElement.parentElement.querySelector('.hover-tooltip');

        如果（全文 && 工具提示）{
          mouseenter.hoverElement.addEventListener('mouseenter', () => {
            工具提示.textContent = fullText;
            positionTooltip(hoverElement, tooltip);
            tooltip.classList.add('显示');
          });

          mouseleave.hoverElement.addEventListener('mouseleave', () => {
            tooltip.classList.remove('显示');
          });

          window.addEventListener('scroll', () => {
            如果 (tooltip.classList.contains('show')) {
              tooltip.classList.remove('显示');
            }
          }, { passive: true });
        }
      });
    }

    function renderSubscriptionTable() {
      const tbody = document.getElementById('subscriptionsBody');
      如果 (!tbody) {
        返回;
      }

      const listShowLunar = document.getElementById('listShowLunar');
      const showLunar = listShowLunar ? listShowLunar.checked : false;
      const searchInput = document.getElementById('searchKeyword');
      const keyword = searchInput ? searchInput.value.trim().toLowerCase() : '';
      const categorySelect = document.getElementById('categoryFilter');
      const selectedCategory = categorySelect ? categorySelect.value.trim().toLowerCase() : '';

      let filtered = Array.isArray(subscriptionsCache) ? [...subscriptionsCache] : [];

      如果 (selectedCategory) {
        filtered = filtered.filter(subscription =>
          normalizeCategoryTokens(subscription.category).some(token => token.toLowerCase() === selectedCategory)
        ）；
      }

      如果（关键字）{
        filtered = filtered.filter(subscription => {
          const haystack = [
            订阅名称
            subscription.customType，
            订阅备注
            订阅类别
          ].filter(Boolean).join(' ').toLowerCase();
          返回 haystack.includes(keyword);
        });
      }

      如果 (filtered.length === 0) {
        tbody.innerHTML = '<tr><td colspan="6" class="text-center py-4 text-gray-500">没有符合条件的订阅</td></tr>';
        返回;
      }

      filtered.sort((a, b) => new Date(a.expiryDate) - new Date(b.expiryDate));
      tbody.innerHTML = '';

      const currentTime = new Date();

      filtered.forEach(subscription => {
        const row = document.createElement('tr');
        row.className = subscription.isActive === false ? 'hover:bg-gray-50 bg-gray-100' : 'hover:bg-gray-50';

        const calendarTypeHtml = subscription.useLunar
          ？ '<div class="text-xs text-purple-600 mt-1">日历类型：农历</div>'
          : '<div class="text-xs text-gray-600 mt-1">日历类型：公历</div>';

        const expiryDate = new Date(subscription.expiryDate);
        const currentDtf = new Intl.DateTimeFormat('en-US', {
          时区：全球时区
          hour12：否，
          年份：'数字'，月份：'两位数'，日期：'两位数'
        });
        const currentParts = currentDtf.formatToParts(currentTime);
        const getCurrent = type => Number(currentParts.find(x => x.type === type).value);
        const currentDateInTimezone = Date.UTC(getCurrent('year'), getCurrent('month') - 1, getCurrent('day'), 0, 0, 0);

        const expiryDtf = new Intl.DateTimeFormat('en-US', {
          时区：全球时区
          hour12：否，
          年份：'数字'，月份：'两位数'，日期：'两位数'
        });
        const expiryParts = expiryDtf.formatToParts(expiryDate);
        const getExpiry = type => Number(expiryParts.find(x => x.type === type).value);
        const expiryDateInTimezone = Date.UTC(getExpiry('year'), getExpiry('month') - 1, getExpiry('day'), 0, 0, 0);

        const daysDiff = Math.round((expiryDateInTimezone - currentDateInTimezone) / (1000 * 60 * 60 * 24));
        const diffMs = expiryDate.getTime() - currentTime.getTime();
        const diffHours = diffMs / (1000 * 60 * 60);

        const reminder = getReminderSettings(subscription);
        const isSoon = reminder.unit === 'hour'
          diffHours >= 0 && diffHours <= reminder.value
          : daysDiff >= 0 && daysDiff <= reminder.value;

        let statusHtml = '';
        如果（!subscription.isActive）{
          statusHtml = '<span class="px-2 py-1 text-xs font-medium rounded-full text-white bg-gray-500"><i class="fas fa-pause-circle mr-1"></i>已停用</span>';
        } else if (daysDiff < 0) {
          statusHtml = '<span class="px-2 py-1 text-xs font-medium rounded-full text-white bg-red-500"><i class="fas fa-exclamation-circle mr-1"></i>已过期</span>';
        } 否则如果 (isSoon) {
          statusHtml = '<span class="px-2 py-1 text-xs font-medium rounded-full text-white bg-yellow-500"><i class="fas fa-exclamation-triangle mr-1"></i>即将到期</span>';
        } 别的 {
          statusHtml = '<span class="px-2 py-1 text-xs font-medium rounded-full text-white bg-green-500"><i class="fas fa-check-circle mr-1"></i>正常</span>';
        }

        let periodText = '';
        如果 (subscription.periodValue && subscription.periodUnit) {
          const unitMap = { 日: '天', 月: '月', 年份: '年' };
          periodText = subscription.periodValue + ' ' + (unitMap[subscription.periodUnit] || subscription.periodUnit);
        }

        const autoRenewIcon = subscription.autoRenew !== false
          ？ '<i class="fas fa-sync-alt text-blue-500 ml-1" title="自动续订"></i>'
          : '<i class="fas fa-ban text-gray-400 ml-1" title="不自动续订"></i>';

        let lunarExpiryText = '';
        let startLunarText = '';
        如果（显示月球）{
          const expiryDateObj = new Date(subscription.expiryDate);
          const lunarExpiry = lunarCalendar.solar2lunar(expiryDateObj.getFullYear(), expiryDateObj.getMonth() + 1, expiryDateObj.getDate());
          lunarExpiryText = lunarExpiry ? lunarExpiry.fullStr : '';

          如果 (subscription.startDate) {
            const startDateObj = new Date(subscription.startDate);
            const lunarStart = lunarCalendar.solar2lunar(startDateObj.getFullYear(), startDateObj.getMonth() + 1, startDateObj.getDate());
            startLunarText = 月球开始 ?月球开始.fullStr : '';
          }
        }

        let notesHtml = '';
        如果 (subscription.notes) {
          const notes = subscription.notes;
          如果（notes.length > 50）{
            const truncatedNotes = notes.substring(0, 50) + '...';
            notesHtml = '<div class="notes-container">' +
              '<div class="notes-text text-xs text-gray-500" data-full-notes="' + notes.replace(/"/g, '"') + '">' +
                截断的笔记 +
              '</div>' +
              '<div class="notes-tooltip"></div>' +
            '</div>';
          } 别的 {
            notesHtml = '<div class="text-xs text-gray-500">' + notes + '</div>';
          }
        }

        const nameHtml = createHoverText(subscription.name, 20, 'text-sm font-medium text-gray-900');
        const typeHtml = createHoverText(subscription.customType || '其他', 15, 'text-sm text-gray-900');
        const periodHtml = periodText ? createHoverText('周期: ' + periodText, 20, 'text-xs text-gray-500 mt-1') : '';

        const categoryTokens = normalizeCategoryTokens(subscription.category);
        const categoryHtml = categoryTokens.length
          ? '<div class="flex flex-wrap gap-2 mt-2">' + categoryTokens.map(cat =>
              '<span class="px-2 py-0.5 bg-indigo-50 text-indigo-600 text-xs rounded-full"><i class="fas fa-tag mr-1"></i>' + cat + '</span>'
            ).join('') + '</div>'
          ：''；

        function formatDateInTimezone(date, timezone) {
          返回 date.toLocaleDateString('zh-CN', {
            时区：时区，
            年份：'数字'，
            月份：两位数，
            日期：两位数
          });
        }

        const expiryDateText = formatDateInTimezone(new Date(subscription.expiryDate), globalTimezone);
        const lunarHtml = lunarExpiryText ? createHoverText('农历: ' + lunarExpiryText, 25, 'text-xs text-blue-600 mt-1') : '';

        let daysLeftText = '';
        如果 (diffMs < 0) {
          const absDays = Math.abs(daysDiff);
          如果 (absDays >= 1) {
            daysLeftText = '已过渡' + absDays + '天';
          } 别的 {
            const absHours = Math.ceil(Math.abs(diffHours));
            daysLeftText = '已过渡' + absHours + '小时';
          }
        } 否则如果 (daysDiff >= 1) {
          daysLeftText = '还剩' + daysDiff + '天';
        } 别的 {
          const hoursLeft = Math.max(0, Math.ceil(diffHours));
          剩余天数 = 剩余时间 > 0 ？ '约' + hoursLeft + '小时后轮胎' : '即将轮胎';
        }

        const startDateText = subscription.startDate
          ? '开始: ' + formatDateInTimezone(new Date(subscription.startDate), globalTimezone) + (startLunarText ? ' (' + startLunarText + ')' : '')
          ：''；
        const startDateHtml = startDateText ? createHoverText(startDateText, 30, 'text-xs text-gray-500 mt-1') : '';

        const reminderExtra = reminder.value === 0
          ？ '<div class="text-xs text-gray-500 mt-1">仅限天气预报时提醒</div>'
          : (reminder.unit === '小时' ? '<div class="text-xs text-gray-500 mt-1">小时级提醒</div>' : '');
        const reminderHtml = '<div><i class="fas fa-bell mr-1"></i>' + reminder.displayText + '</div>' + reminderExtra;

        row.innerHTML =
          '<td data-label="名称" class="px-4 py-3"><div class="td-content-wrapper">' +
            nameHtml +
            notesHtml +
          '</div></td>' +
          '<td data-label="类型" class="px-4 py-3"><div class="td-content-wrapper space-y-1">' +
            '<div class="flex items-center gap-1">' +
              '<i class="fas fa-layer-group text-gray-400"></i>' +
              typeHtml +
            '</div>' +
            (periodHtml ? '<div class="flex items-center gap-1">' + periodHtml + autoRenewIcon + '</div>' : '') +
            类别：HTML+
            calendarTypeHtml +
          '</div></td>' +
          '<td data-label="兑时间" class="px-4 py-3"><div class="td-content-wrapper">' +
            '<div class="text-sm text-gray-900">' + expiryDateText + '</div>' +
            lunarHtml +
            '<div class="text-xs text-gray-500 mt-1">' + daysLeftText + '</div>' +
            startDateHtml +
          '</div></td>' +
          '<td data-label="提醒设置" class="px-4 py-3"><div class="td-content-wrapper">' +
            提醒Html +
          '</div></td>' +
          '<td data-label="状态" class="px-4 py-3"><div class="td-content-wrapper">' + statusHtml + '</div></td>' +
          '<td data-label="操作" class="px-4 py-3">' +
            '<div class="action-buttons-wrapper">' +
              '<button class="edit btn-primary text-white px-2 py-1 rounded text-xs whitespace-nowrap" data-id="' + subscription.id + '"><i class="fas fa-edit mr-1"></i>编辑</button>' +
              '<button class="test-notify btn-info text-white px-2 py-1 rounded text-xs whitespace-nowrap" data-id="' + subscription.id + '"><i class="fas fa-paper-plane mr-1"></i>测试</button>' +
              '<button class="delete btn-danger text-white px-2 py-1 rounded text-xs whitespace-nowrap" data-id="' + subscription.id + '"><i class="fas fa-trash-alt mr-1"></i>删除</button>' +
              (订阅已激活)
                ? '<button class="toggle-status btn-warning text-white px-2 py-1 rounded text-xs whitespace-nowrap" data-id="' + subscription.id + '" data-action="deactivate"><i class="fas fa-pause-circle mr-1"></i>停止使用</button>'
                : '<button class="toggle-status btn-success text-white px-2 py-1 rounded text-xs whitespace-nowrap" data-id="' + subscription.id + '" data-action="activate"><i class="fas fa-play-circle mr-1"></i>启用</button>') +
            '</div>' +
          '</td>';

        tbody.appendChild(row);
      });

      document.querySelectorAll('.edit').forEach(button => {
        button.addEventListener('click', editSubscription);
      });

      document.querySelectorAll('.delete').forEach(button => {
        button.addEventListener('click', deleteSubscription);
      });

      document.querySelectorAll('.toggle-status').forEach(button => {
        button.addEventListener('click', toggleSubscriptionStatus);
      });

      document.querySelectorAll('.test-notify').forEach(button => {
        button.addEventListener('click', testSubscriptionNotification);
      });

      attachHoverListeners();
    }

    const searchInput = document.getElementById('searchKeyword');
    如果 (搜索输入) {
      searchInput.addEventListener('input', () => {
        清除超时(searchDebounceTimer);
        searchDebounceTimer = setTimeout(() => renderSubscriptionTable(), 200);
      });
    }

    const categorySelect = document.getElementById('categoryFilter');
    如果 (categorySelect) {
      categorySelect.addEventListener('change', () => renderSubscriptionTable());
    }

    // 获取所有订阅并按时间排序
    异步函数 loadSubscriptions(showLoading = true) {
      尝试 {
        const listShowLunar = document.getElementById('listShowLunar');
        const saved = localStorage.getItem('showLunar');
        如果 (listShowLunar) {
          如果 (已保存 !== null) {
            listShowLunar.checked = saved === 'true';
          } 别的 {
            listShowLunar.checked = true;
          }
        }

        const tbody = document.getElementById('subscriptionsBody');
        如果 (tbody && showLoading) {
          tbody.innerHTML = '<tr><td colspan="6" class="text-center py-4"><i class="fas fa-spinner fa-spin mr-2"></i>加载中...</td></tr>';
        }

        const response = await fetch('/api/subscriptions');
        const data = await response.json();

        subscriptionsCache = Array.isArray(data) ? data : [];
        填充类别过滤器(订阅缓存);
        renderSubscriptionTable();
      } catch (error) {
        console.error('加载订阅失败:', error);
        const tbody = document.getElementById('subscriptionsBody');
        如果 (tbody) {
          tbody.innerHTML = '<tr><td colspan="6" class="text-center py-4 text-red-500"><i class="fas fa-exclamation-circle mr-2"></i>加载失败，请刷新页面重试</td></tr>';
        }
        showToast('加载订阅列表失败', '错误');
      }
    }
    
    异步函数 testSubscriptionNotification(e) {
        const button = e.target.tagName === 'BUTTON' ? e.target : e.target.parentElement;
        const id = button.dataset.id;
        const OriginalContent = Button.innerHTML;
        button.innerHTML = '<i class="fas fa-spinner fa-spin mr-1"></i>';
        按钮已禁用 = true;

        尝试 {
            const response = await fetch('/api/subscriptions/' + id + '/test-notify', { method: 'POST' });
            const result = await response.json();
            如果 (结果成功) {
                showToast(result.message || '测试通知已发送', '成功');
            } 别的 {
                showToast(result.message || '测试通知发送失败', '错误');
            }
        } catch (error) {
            console.error('测试通知失败:', error);
            showToast('发送测试通知时发生错误', 'error');
        } 最后 {
            按钮.innerHTML = 原始内容;
            按钮已禁用 = false;
        }
    }
    
    异步函数 toggleSubscriptionStatus(e) {
      const id = e.target.dataset.id || e.target.parentElement.dataset.id;
      const action = e.target.dataset.action || e.target.parentElement.dataset.action;
      const isActivate = action === 'activate';
      
      const button = e.target.tagName === 'BUTTON' ? e.target : e.target.parentElement;
      const OriginalContent = Button.innerHTML;
      Button.innerHTML = '<i class="fas fa-spinner fa-spin mr-2"></i>' + (isActivate ? '启用中...' : '禁用中...');
      按钮已禁用 = true;
      
      尝试 {
        const response = await fetch('/api/subscriptions/' + id + '/toggle-status', {
          方法：'POST'，
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({ isActive: isActivate })
        });
        
        如果 (response.ok) {
          showToast((isActivate ? '启用' : '失效') + '成功', '成功');
          加载订阅();
        } 别的 {
          const error = await response.json();
          showToast((isActivate ? '启用' : '失效') + '失败: ' + (error.message || '未知错误'), 'error');
          按钮.innerHTML = 原始内容;
          按钮已禁用 = false;
        }
      } catch (error) {
        console.error((isActivate ? '启用' : '失效') + '订阅失败:', error);
        showToast((isActivate ? '启用' : '失效') + '失败，请稍后再试', 'error');
        按钮.innerHTML = 原始内容;
        按钮已禁用 = false;
      }
    }
    
    document.getElementById('addSubscriptionBtn').addEventListener('click', () => {
      document.getElementById('modalTitle').textContent = '添加新订阅';
      document.getElementById('subscriptionModal').classList.remove('hidden');

      document.getElementById('subscriptionForm').reset();
      document.getElementById('subscriptionId').value = '';
      清除字段错误();

      const Today = new Date().toISOString().split('T')[0]; // 前置使用本地时间
      document.getElementById('startDate').value = today;
      document.getElementById('category').value = '';
      document.getElementById('reminderValue').value = '7';
      document.getElementById('reminderUnit').value = 'day';
      document.getElementById('isActive').checked = true;
      document.getElementById('autoRenew').checked = true;

      加载 LunarPreference();
      计算到期日();
      setupModalEventListeners();
    });

    // 自定义日期选择器功能
    class CustomDatePicker {
      constructor(inputId, pickerId, calendarId, monthId, yearId, prevBtnId, nextBtnId) {
        console.log('CustomDatePicker构造函数:', { inputId, pickerId, calendarId,monthId,yearId, prevBtnId, nextBtnId });
        
        this.input = document.getElementById(inputId);
        this.picker = document.getElementById(pickerId);
        this.calendar = document.getElementById(calendarId);
        this.monthElement = document.getElementById(monthId);
        this.yearElement = document.getElementById(yearId);
        this.prevBtn = document.getElementById(prevBtnId);
        this.nextBtn = document.getElementById(nextBtnId);
        
        // 新增元素
        this.monthPicker = document.getElementById(pickerId.replace('Picker', 'MonthPicker'));
        this.yearPicker = document.getElementById(pickerId.replace('Picker', 'YearPicker'));
        this.backToCalendarBtn = document.getElementById(pickerId.replace('Picker', 'BackToCalendar'));
        this.backToCalendarFromYearBtn = document.getElementById(pickerId.replace('Picker', 'BackToCalendarFromYear'));
        this.goToTodayBtn = document.getElementById(pickerId.replace('Picker', 'GoToToday'));
        this.prevYearDecadeBtn = document.getElementById(pickerId.replace('Picker', 'PrevYearDecade'));
        this.nextYearDecadeBtn = document.getElementById(pickerId.replace('Picker', 'NextYearDecade'));
        this.yearRangeElement = document.getElementById(pickerId.replace('Picker', 'YearRange'));
        this.yearGrid = document.getElementById(pickerId.replace('Picker', 'YearGrid'));
        
        console.log('找到的元素:', {
          输入：!!this.input，
          选择器：!!this.picker，
          日历：!!this.calendar，
          monthElement: !!this.monthElement,
          yearElement: !!this.yearElement,
          prevBtn: !!this.prevBtn,
          nextBtn: !!this.nextBtn
        });
        
        this.currentDate = new Date();
        this.selectedDate = null;
        this.currentView = 'calendar'; // 'calendar', 'month', 'year'
        this.yearDecade = Math.floor(this.currentDate.getFullYear() / 10) * 10;
        
        this.init();
      }
      
      init() {
        console.log('初始化日期选择器，输入框:', !!this.input, '选择器:', !!this.picker);
        
        // 绑定基本事件
        如果 (this.input) {
          // 移除之前的事件监听器（如果存在）
          this.input.removeEventListener('click', this._forceShowHandler);
          this._forceShowHandler = () => this.forceShow();
          this.input.addEventListener('click', this._forceShowHandler);
          如果 (this._manualInputHandler) {
            this.input.removeEventListener('blur', this._manualInputHandler);
          }
          this._manualInputHandler = () => this.syncFromInputValue();
          this.input.addEventListener('blur', this._manualInputHandler);

          如果 (this._manualKeydownHandler) {
            this.input.removeEventListener('keydown', this._manualKeydownHandler);
          }
          this._manualKeydownHandler = (event) => {
            如果 (event.key === 'Enter') {
              event.preventDefault();
              this.syncFromInputValue();
            }
          };
          this.input.addEventListener('keydown', this._manualKeydownHandler);
        }
        
        如果 (this.prevBtn) {
          this.prevBtn.removeEventListener('click', this._prevHandler);
          this._prevHandler = () => this.previousMonth();
          this.prevBtn.addEventListener('click', this._prevHandler);
        }
        
        如果 (this.nextBtn) {
          this.nextBtn.removeEventListener('click', this._nextHandler);
          this._nextHandler = () => this.nextMonth();
          this.nextBtn.addEventListener('click', this._nextHandler);
        }
        
        // 绑定年份和年份点击事件
        如果 (this.monthElement) {
          this.monthElement.removeEventListener('click', this._showMonthHandler);
          this._showMonthHandler = () => this.showMonthPicker();
          this.monthElement.addEventListener('click', this._showMonthHandler);
        }
        
        如果 (this.yearElement) {
          this.yearElement.removeEventListener('click', this._showYearHandler);
          this._showYearHandler = () => this.showYearPicker();
          this.yearElement.addEventListener('click', this._showYearHandler);
        }
        
        // 绑定月份选择器事件
        如果 (this.monthPicker) {
          this.monthPicker.removeEventListener('click', this._monthSelectHandler);
          this._monthSelectHandler = (e) => {
            如果 (e.target.classList.contains('month-option')) {
              const month = parseInt(e.target.dataset.month);
              this.selectMonth(month);
            }
          };
          this.monthPicker.addEventListener('click', this._monthSelectHandler);
        }
        
        如果 (this.backToCalendarBtn) {
          this.backToCalendarBtn.removeEventListener('click', this._backToCalendarHandler);
          this._backToCalendarHandler = () => this.showCalendar();
          this.backToCalendarBtn.addEventListener('click', this._backToCalendarHandler);
        }
        
        如果 (this.backToCalendarFromYearBtn) {
          this.backToCalendarFromYearBtn.removeEventListener('click', this._backToCalendarFromYearHandler);
          this._backToCalendarFromYearHandler = () => this.showCalendar();
          this.backToCalendarFromYearBtn.addEventListener('click', this._backToCalendarFromYearHandler);
        }
        
        // 绑定年份选择器事件
        如果 (this.prevYearDecadeBtn) {
        this.prevYearDecadeBtn.removeEventListener('click', this._prevYearDecadeHandler);
        this._prevYearDecadeHandler = (e) => {
            e.stopPropagation(); // 防止事件冒泡到表单
            this.previousYearDecade();
        };
        this.prevYearDecadeBtn.addEventListener('click', this._prevYearDecadeHandler);
        }

        如果 (this.nextYearDecadeBtn) {
        this.nextYearDecadeBtn.removeEventListener('click', this._nextYearDecadeHandler);
        this._nextYearDecadeHandler = (e) => {
            e.stopPropagation(); // 防止事件冒泡到表单
            this.nextYearDecade();
        };
        this.nextYearDecadeBtn.addEventListener('click', this._nextYearDecadeHandler);
}
        
        // 绑定回到今天事件
        如果 (this.goTodayBtn) {
          this.goToTodayBtn.removeEventListener('click', this._goToTodayHandler);
          this._goToTodayHandler = () => this.goToToday();
          this.goToTodayBtn.addEventListener('click', this._goToTodayHandler);
        }
        
        // 点击外部关闭
        如果 (this._outsideClickHandler) {
          document.removeEventListener('click', this._outsideClickHandler);
        }
        this._outsideClickHandler = (e) => {
          如果 (this.picker && !this.picker.contains(e.target) && !this.input.contains(e.target)) {
            console.log('点击外部，隐藏日期选择器');
            this.hide();
          }
        };
        document.addEventListener('click', this._outsideClickHandler);
        
        // 初始化显示
        this.syncFromInputValue();
        this.render();
        this.renderYearGrid();
      }
      
      切换() {
        console.log('toggle 被调用');
        console.log('picker 元素:', this.picker);
        console.log('picker 类名:', this.picker ? this.picker.className : 'null');
        console.log('是否包含hidden:', this.picker ? this.picker.classList.contains('hidden') : 'null');
        
        如果 (this.picker && this.picker.classList.contains('hidden')) {
          console.log('显示日期选择器');
          this.show();
        } 别的 {
          console.log('隐藏日期选择器');
          this.hide();
        }
      }
      
      // 强制显示日期选择器
      forceShow() {
        console.log('forceShow 被调用');
        如果 (this.picker) {
          //确保选择器显示
          this.picker.classList.remove('hidden');
          // 重置到日历视图
          this.currentView = 'calendar';
          this.hideAllViews();
          this.render();
          console.log('日期选择器已显示');
        } 别的 {
          console.error('日期选择器元素不存在');
        }
      }
      
      展示（） {
        如果 (this.picker) {
          this.picker.classList.remove('hidden');
          this.render();
        }
      }
      
      隐藏（） {
        如果 (this.picker) {
          this.picker.classList.add('hidden');
        }
      }
      
      previousMonth() {
        this.currentDate.setMonth(this.currentDate.getMonth() - 1);
        this.render();
      }
      
      nextMonth() {
        this.currentDate.setMonth(this.currentDate.getMonth() + 1);
        this.render();
      }
      
      selectDate(date) {
        this.selectedDate = date;
        如果 (this.input) {
          // 使用本地时间格式化，避免时区问题
          const year = date.getFullYear();
          const month = String(date.getMonth() + 1).padStart(2, '0');
          const day = String(date.getDate()).padStart(2, '0');
          this.input.value = year + '-' + month + '-' + day;
        }
        this.hide();
        
        // 触发change事件，但不冒泡到表单
        如果 (this.input) {
          const event = new Event('change', { bubbles: false });
          this.input.dispatchEvent(event);
        }
      }

      syncFromInputValue() {
        如果 (!this.input) {
          返回;
        }
        const value = this.input.value.trim();
        如果 (!value) {
          this.selectedDate = null;
          返回;
        }

        const match = value.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/);
        如果 (!match) {
          如果 (typeof showToast === 'function') {
            showToast('日期格式需为YYYY-MM-DD', '警告');
          }
          返回;
        }

        const year = Number(match[1]);
        const month = Number(match[2]);
        const day = Number(match[3]);
        const parsed = new Date(year, month - 1, day);
        如果 (isNaN(parsed.getTime()) || parsed.getFullYear() !== year || parsed.getMonth() !== month - 1 || parsed.getDate() !== day) {
          如果 (typeof showToast === 'function') {
            showToast('请输入有效的日期', '警告');
          }
          返回;
        }

        this.selectedDate = 已解析;
        this.currentDate = new Date(parsed);
        this.render();

        const event = new Event('change', { bubbles: false });
        this.input.dispatchEvent(event);
      }
      
      使成为（） {
        如果 (!this.monthElement || !this.yearElement || !this.calendar) 返回;
        
        const year = this.currentDate.getFullYear();
        const month = this.currentDate.getMonth();
        
        // 更新年份显示
        this.monthElement.textContent = (month + 1) + '月';
        this.yearElement.textContent = year;
        
        // 清空日历
        this.calendar.innerHTML = '';
        
        // 获取当月第一天和最后一天
        const firstDay = new Date(year, month, 1);
        const lastDay = new Date(year, month + 1, 0);
        const startDate = new Date(firstDay);
        startDate.setDate(startDate.getDate() - firstDay.getDay());
        
        // 生成日历网格
        for (let i = 0; i < 42; i++) {
          const date = new Date(startDate);
          date.setDate(startDate.getDate() + i);
          
          const dayElement = document.createElement('div');
          dayElement.className = 'calendar-day';
          
          //判断是否是当前月份
          如果 (date.getMonth() !== month) {
            dayElement.classList.add('other-month');
          }
          
          //判断是否是今天
          const today = new Date();
          如果 (date.toDateString() === today.toDateString()) {
            dayElement.classList.add('today');
          }
          
          //判断日期是否被选中
          如果 (this.selectedDate && date.toDateString() === this.selectedDate.toDateString()) {
            dayElement.classList.add('selected');
          }
          
          // 获取农历信息
          let lunarText = '';
          尝试 {
            const lunar = lunarCalendar.solar2lunar(date.getFullYear(), date.getMonth() + 1, date.getDate());
            如果（月球）{
              如果（lunar.day === 1）{
                // 初一，只显示月份
                月球文本 = 月球.isLeap ? '闰' + 月历.monthStr.replace('闰', '') : 月历.monthStr;
              } 别的 {
                // 不是初一，显示日
                lunarText = lunar.dayStr;
              }
            }
          } catch (error) {
            console.error('农历转换错误:', error);
          }
          
          dayElement.innerHTML =
            '<div>' + date.getDate() + '</div>' +
            '<div class="lunar-text">' + lunarText + '</div>';
          
          dayElement.addEventListener('click', () => this.selectDate(date));
          
          this.calendar.appendChild(dayElement);
        }
      }
      
      // 显示月份选择器
      showMonthPicker() {
        this.currentView = 'month';
        this.hideAllViews();
        如果 (this.monthPicker) {
          this.monthPicker.classList.remove('hidden');
          // 高亮当前月份
          const monthOptions = this.monthPicker.querySelectorAll('.month-option');
          monthOptions.forEach((option, index) => {
            option.classList.remove('selected');
            如果 (index === this.currentDate.getMonth()) {
              option.classList.add('selected');
            }
          });
        }
      }
      
      // 显示年份选择器
      showYearPicker() {
        this.currentView = 'year';
        this.hideAllViews();
        如果 (this.yearPicker) {
          this.yearPicker.classList.remove('hidden');
        }
        this.renderYearGrid();
      }
      
      // 显示日历视图
      showCalendar() {
        this.currentView = 'calendar';
        this.hideAllViews();
        this.render();
      }
      
      // 隐藏所有视图
      hideAllViews() {
        如果 (this.monthPicker) this.monthPicker.classList.add('hidden');
        如果 (this.yearPicker) this.yearPicker.classList.add('hidden');
        //注意：不隐藏日历视图，因为它是主视图
      }
      
      // 选择月份
      selectMonth(month) {
        this.currentDate.setMonth(month);
        this.showCalendar();
      }
      
      // 选择年份
      selectYear(year) {
        this.currentDate.setFullYear(year);
        this.showCalendar();
      }
      
      // 上十年
      previousYearDecade() {
        this.yearDecade -= 10;
        this.renderYearGrid();
      }
      
      // 下一个十年
      下一个十年() {
        this.yearDecade += 10;
        this.renderYearGrid();
      }
      
      // 配送年份网格
      renderYearGrid() {
        如果 (!this.yearGrid || !this.yearRangeElement) 返回；
        
        const startYear = this.yearDecade;
        const endYear = this.yearDecade + 9;
        
        // 更新年份范围显示
        this.yearRangeElement.textContent = startYear + '-' + endYear;
        
        // 清空年份网格
        this.yearGrid.innerHTML = '';
        
        // 生成年份按钮
        for (let year = startYear; year <= endYear; year++) {
          const yearBtn = document.createElement('button');
          yearBtn.type = '按钮';
          yearBtn.className = 'year-option px-3 py-2 text-sm rounded hover:bg-gray-100';
          yearBtn.textContent = year;
          yearBtn.dataset.year = year;
          
          // 高亮当前年份
          如果 (year === this.currentDate.getFullYear()) {
            yearBtn.classList.add('bg-indigo-100', 'text-indigo-600');
          }
          
          // 限制年份范围 1900-2100
          如果（年份 < 1900 || 年份 > 2100）{
            yearBtn.disabled = true;
            yearBtn.classList.add('opacity-50', 'cursor-not-allowed');
          } 别的 {
            yearBtn.addEventListener('click', () => this.selectYear(year));
          }
          
          this.yearGrid.appendChild(yearBtn);
        }
      }
      
      // 回到今天
      goToToday() {
        this.currentDate = new Date();
        this.yearDecade = Math.floor(this.currentDate.getFullYear() / 10) * 10;
        this.showCalendar();
      }
      
      破坏（） {
        this.hide();
        
        //清理事件监听器
        如果 (this.input && this._forceShowHandler) {
          this.input.removeEventListener('click', this._forceShowHandler);
        }
        如果 (this.input && this._manualInputHandler) {
          this.input.removeEventListener('blur', this._manualInputHandler);
        }
        如果 (this.input && this._manualKeydownHandler) {
          this.input.removeEventListener('keydown', this._manualKeydownHandler);
        }
        如果 (this.prevBtn && this._prevHandler) {
          this.prevBtn.removeEventListener('click', this._prevHandler);
        }
        如果 (this.nextBtn && this._nextHandler) {
          this.nextBtn.removeEventListener('click', this._nextHandler);
        }
        如果 (this.monthElement && this._showMonthHandler) {
          this.monthElement.removeEventListener('click', this._showMonthHandler);
        }
        如果 (this.yearElement && this._showYearHandler) {
          this.yearElement.removeEventListener('click', this._showYearHandler);
        }
        如果 (this.monthPicker && this._monthSelectHandler) {
          this.monthPicker.removeEventListener('click', this._monthSelectHandler);
        }
        如果 (this.backToCalendarBtn && this._backToCalendarHandler) {
          this.backToCalendarBtn.removeEventListener('click', this._backToCalendarHandler);
        }
        如果 (this.backToCalendarFromYearBtn && this._backToCalendarFromYearHandler) {
          this.backToCalendarFromYearBtn.removeEventListener('click', this._backToCalendarFromYearHandler);
        }
        如果 (this.prevYearDecadeBtn && this._prevYearDecadeHandler) {
          this.prevYearDecadeBtn.removeEventListener('click', this._prevYearDecadeHandler);
        }
        如果 (this.nextYearDecadeBtn && this._nextYearDecadeHandler) {
          this.nextYearDecadeBtn.removeEventListener('click', this._nextYearDecadeHandler);
        }
        如果 (this.goTodayBtn && this._goToTodayHandler) {
          this.goToTodayBtn.removeEventListener('click', this._goToTodayHandler);
        }
        如果 (this._outsideClickHandler) {
          document.removeEventListener('click', this._outsideClickHandler);
        }
      }
    }
    
    function setupModalEventListeners() {
      // 获取DOM元素
      const calculateExpiryBtn = document.getElementById('calculateExpiryBtn');
      const useLunar = document.getElementById('useLunar');
      const showLunar = document.getElementById('showLunar');
      const startDate = document.getElementById('startDate');
      const expiryDate = document.getElementById('expiryDate');
      const cancelBtn = document.getElementById('cancelBtn');
      
      // 直接绑定事件监听器（简化处理，避免重复移除的问题）
      如果 (计算过期按钮) {
        calculateExpiryBtn.addEventListener('click', calculateExpiryDate);
      }
      如果（使用月球）{
        useLunar.addEventListener('change', calculateExpiryDate);
      }
      如果（显示月球）{
        showLunar.addEventListener('change', toggleLunarDisplay);
      }
      如果 (开始日期) {
        startDate.addEventListener('change', () => updateLunarDisplay('startDate', 'startDateLunar'));
      }
      如果（到期日）{
        expiryDate.addEventListener('change', () => updateLunarDisplay('expiryDate', 'expiryDateLunar'));
      }
      如果 (取消按钮) {
        cancelBtn.addEventListener('click', () => {
          document.getElementById('subscriptionModal').classList.add('hidden');
        });
      }
      // 为周期相关字段添加事件监听
      ['startDate', 'periodValue', 'periodUnit'].forEach(id => {
        const element = document.getElementById(id);
        如果（元素）{
          element.addEventListener('change', calculateExpiryDate);
        }
      });

      // 初始化自定义日期选择器
      尝试 {
        // 在该实例之前安全地清理
        如果 (window.startDatePicker && typeof window.startDatePicker.destroy === 'function') {
          window.startDatePicker.destroy();
        }
        如果 (window.expiryDatePicker && typeof window.expiryDatePicker.destroy === 'function') {
          window.expiryDatePicker.destroy();
        }
        
        //清理全局变量
        window.startDatePicker = null;
        window.expiryDatePicker = null;
        
        //确保DOM要素存在之后创建选择器
        setTimeout(() => {
          console.log('创建开始日期选择器...');
          window.startDatePicker = new CustomDatePicker(
            'startDate', 'startDatePicker', 'startDateCalendar',
            'startDateMonth', 'startDateYear', 'startDatePrevMonth', 'startDateNextMonth'
          ）；
          
          console.log('创建日期选择器...');
          window.expiryDatePicker = new CustomDatePicker(
            'expiryDate'、'expiryDatePicker'、'expiryDateCalendar'
            'expiryDateMonth', 'expiryDateYear', 'expiryDatePrevMonth', 'expiryDateNextMonth'
          ）；
          
          console.log('日期选择器初始化完成');
        }, 50);
      } catch (error) {
        console.error('初始化日期选择器失败:', error);
        //确定清理失败的实例
        window.startDatePicker = null;
        window.expiryDatePicker = null;
      }
    }

	// 3.新增，修改calculateExpiryDate函数，支持农历周期推算     
	函数 calculateExpiryDate() {
	  const startDate = document.getElementById('startDate').value;
	  const periodValue = parseInt(document.getElementById('periodValue').value);
	  const periodUnit = document.getElementById('periodUnit').value;
	  const useLunar = document.getElementById('useLunar').checked;

	  如果 (!startDate || !periodValue || !periodUnit) {
		返回;
	  }

	  如果（使用月球）{
		// 农历推算
		const start = new Date(startDate);
		const lunar = lunarCalendar.solar2lunar(start.getFullYear(), start.getMonth() + 1, start.getDate());
		let nextLunar = addLunarPeriod(lunar, periodValue, periodUnit);
		const solar = lunar2solar(nextLunar);
		
		// 使用与公历相同的方式创建日期  
		const expiry = new Date(开始日期); // 从原始日期开始  
		expiry.setFullYear(solar.year);  
		expiry.setMonth(solar.month - 1);  
		expiry.setDate(solar.day);  
		document.getElementById('expiryDate').value = expiry.toISOString().split('T')[0];
		console.log('start:', start);
		console.log('nextLunar:', nextLunar);
		console.log('过期时间:', 过期时间);
		console.log('expiryDate:', document.getElementById('expiryDate').value);
		
		console.log('来自 lunar2solar 的 solar 数据：', solar);  
		console.log('solar.year:', solar.year, 'solar.month:', solar.month, 'solar.day:', solar.day);
		console.log('expiry.getTime():', expiry.getTime());  
		console.log('expiry.toString():', expiry.toString());
		
		
	  } 别的 {
		// 公历推算
		const start = new Date(startDate);
		const expiry = new Date(start);
		如果 (periodUnit === 'day') {
		  expiry.setDate(start.getDate() + periodValue);
		} else if (periodUnit === 'month') {
		  expiry.setMonth(start.getMonth() + periodValue);
		} else if (periodUnit === 'year') {
		  expiry.setFullYear(start.getFullYear() + periodValue);
		}
		document.getElementById('expiryDate').value = expiry.toISOString().split('T')[0];
		console.log('start:', start);
		console.log('过期时间:', 过期时间);
		console.log('expiryDate:', document.getElementById('expiryDate').value);
	  }

	  // 更新农历显示
	  updateLunarDisplay('startDate', 'startDateLunar');
	  updateLunarDisplay('expiryDate', 'expiryDateLunar');
	}
    
    document.getElementById('closeModal').addEventListener('click', () => {
      document.getElementById('subscriptionModal').classList.add('hidden');
    });
    
    // 禁止点击弹窗外区域关闭弹窗，防止误操作丢失内容
    // document.getElementById('subscriptionModal').addEventListener('click', (event) => {
    // 如果 (event.target === document.getElementById('subscriptionModal')) {
    // document.getElementById('subscriptionModal').classList.add('hidden');
    // }
    // });
    
	
	// 4. 新增，监听 useLunar 修改变化时也自动重新计算
	// 注意：这个事件监听器已经在 setupModalEventListeners 中处理了   
   // 新增修改，表单提交时带上 useLunar 字段
    document.getElementById('subscriptionForm').addEventListener('submit', async (e) => {
      e.preventDefault();
      
      如果 (!validateForm()) {
        返回;
      }
      
      const id = document.getElementById('subscriptionId').value;
      const reminderUnit = document.getElementById('reminderUnit').value;
      const reminderValue = Number(document.getElementById('reminderValue').value) || 0;

      const subscription = {
        name: document.getElementById('name').value.trim(),
        customType: document.getElementById('customType').value.trim(),
        类别: document.getElementById('category').value.trim(),
        备注：document.getElementById('notes').value.trim() || '',
        isActive：document.getElementById('isActive').checked，
        autoRenew: document.getElementById('autoRenew').checked,
        startDate: document.getElementById('startDate').value,
        expiryDate: document.getElementById('expiryDate').value,
        periodValue: Number(document.getElementById('periodValue').value),
        periodUnit: document.getElementById('periodUnit').value,
        提醒单元：提醒单元，
        提醒值：提醒值，
        reminderDays: reminderUnit === 'day' ? reminderValue : 0,
        reminderHours: reminderUnit === 'hour' ? reminderValue : undefined,
        useLunar: document.getElementById('useLunar').checked
      };
      
      const submitButton = e.target.querySelector('button[type="submit"]');
      const originalContent = submitButton.innerHTML;
      commitButton.innerHTML = '<i class="fas fa-spinner fa-spin mr-2"></i>' + (id ? '更新中...' : '保存中...');
      submitButton.disabled = true;
      
      尝试 {
        const url = id ? '/api/subscriptions/' + id : '/api/subscriptions';
        const method = id ? 'PUT' : 'POST';
        
        const response = await fetch(url, {
          方法：方法，
          headers: { 'Content-Type': 'application/json' },
          正文：JSON.stringify(subscription)
        });
        
        const result = await response.json();
        
        如果 (结果成功) {
          showToast((id ? '更新' : '添加') + '订阅成功', '成功');
          document.getElementById('subscriptionModal').classList.add('hidden');
          加载订阅();
        } 别的 {
          showToast((id ? '更新' : '添加') + '订阅失败: ' + (result.message || '未知错误'), '错误');
        }
      } catch (error) {
        console.error((id ? '更新' : '添加') + '订阅失败:', error);
        showToast((id ? '更新' : '添加') + '订阅失败，请稍后再试', '错误');
      } 最后 {
        submitButton.innerHTML = originalContent;
        submitButton.disabled = false;
      }
    });
    
	    // 新增修改，编辑订阅时回显 useLunar 字段
    异步函数 editSubscription(e) {
      const id = e.target.dataset.id || e.target.parentElement.dataset.id;
      
      尝试 {
        const response = await fetch('/api/subscriptions/' + id);
        const subscription = await response.json();
        
        如果（订阅）{
          document.getElementById('modalTitle').textContent = '编辑订阅';
          document.getElementById('subscriptionId').value = subscription.id;
          document.getElementById('name').value = subscription.name;
          document.getElementById('customType').value = subscription.customType || '';
          document.getElementById('category').value = subscription.category || '';
          document.getElementById('notes').value = subscription.notes || '';
          document.getElementById('isActive').checked = subscription.isActive !== false;
          document.getElementById('autoRenew').checked = subscription.autoRenew !== false;
          document.getElementById('startDate').value = subscription.startDate ? subscription.startDate.split('T')[0] : '';
          document.getElementById('expiryDate').value = subscription.expiryDate ? subscription.expiryDate.split('T')[0] : '';
          document.getElementById('periodValue').value = subscription.periodValue || 1;
          document.getElementById('periodUnit').value = subscription.periodUnit || 'month';
          const reminderUnit = subscription.reminderUnit || (subscription.reminderHours !== undefined ? 'hour' : 'day');
          let reminderValue;
          如果 (reminderUnit === 'hour') {
            if (subscription.reminderValue !== undefined && subscription.reminderValue !== null) {
              reminderValue = subscription.reminderValue;
            } else if (subscription.reminderHours !== undefined) {
              reminderValue = subscription.reminderHours;
            } 别的 {
              提醒值 = 0；
            }
          } 别的 {
            if (subscription.reminderValue !== undefined && subscription.reminderValue !== null) {
              reminderValue = subscription.reminderValue;
            } else if (subscription.reminderDays !== undefined) {
              提醒值 = 订阅.提醒天数;
            } 别的 {
              提醒值 = 7；
            }
          }
          document.getElementById('reminderUnit').value = reminderUnit;
          document.getElementById('reminderValue').value = reminderValue;
          document.getElementById('useLunar').checked = !!subscription.useLunar;
          
          清除字段错误();
          加载 LunarPreference();
          document.getElementById('subscriptionModal').classList.remove('hidden');
          
          // 重要：编辑订阅时也需要重新设置事件监听器
          setupModalEventListeners();

          // 更新农历显示
          setTimeout(() => {
            updateLunarDisplay('startDate', 'startDateLunar');
            updateLunarDisplay('expiryDate', 'expiryDateLunar');
          }, 100);
        }
      } catch (error) {
        console.error('获取订阅信息失败:', error);
        showToast('获取订阅信息失败', '错误');
      }
    }
    
    异步函数 deleteSubscription(e) {
      const id = e.target.dataset.id || e.target.parentElement.dataset.id;
      
      if (!confirm('确定要删除这个订阅吗？此操作不可恢复。')) {
        返回;
      }
      
      const button = e.target.tagName === 'BUTTON' ? e.target : e.target.parentElement;
      const OriginalContent = Button.innerHTML;
      Button.innerHTML = '<i class="fas fa-spinner fa-spin mr-2"></i>删除中...';
      按钮已禁用 = true;
      
      尝试 {
        const response = await fetch('/api/subscriptions/' + id, {
          方法：'删除'
        });
        
        如果 (response.ok) {
          showToast('删除成功', '成功');
          加载订阅();
        } 别的 {
          const error = await response.json();
          showToast('删除失败: ' + (error.message || '未知错误'), 'error');
          按钮.innerHTML = 原始内容;
          按钮已禁用 = false;
        }
      } catch (error) {
        console.error('删除订阅失败:', error);
        showToast('删除失败，请稍后再试', 'error');
        按钮.innerHTML = 原始内容;
        按钮已禁用 = false;
      }
    }
    
    // 全局时区配置
    let globalTimezone = 'UTC';
    
    // 检测时区更新
    函数 checkTimezoneUpdate() {
      const lastUpdate = localStorage.getItem('timezoneUpdated');
      如果 (lastUpdate) {
        const updateTime = parseInt(lastUpdate);
        const currentTime = Date.now();
        // 如果时区更新发生在最近5秒内，则刷新页面
        如果（当前时间 - 更新时间 < 5000）{
          localStorage.removeItem('timezoneUpdated');
          window.location.reload();
        }
      }
    }
    
    // 页面加载时检查时区更新
    window.addEventListener('load', () => {
      检查时区更新();
      加载订阅();
    });
    
    // 定期检查时区更新（每2秒检查一次）
    setInterval(checkTimezoneUpdate, 2000);

    // 实时显示系统时间和时区
    异步函数 showSystemTime() {
      尝试 {
        // 获取后台配置的时区
        const response = await fetch('/api/config');
        const config = await response.json();
        globalTimezone = config.TIMEZONE || 'UTC';
        
        // 删除当前时间
        function formatTime(dt, tz) {
          return dt.toLocaleString('zh-CN', { timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit' });
        }
        function formatTimezoneDisplay(tz) {
          尝试 {
            // 使用更准确的时区偏移计算方法
            const now = new Date();
            const dtf = new Intl.DateTimeFormat('en-US', {
              时区：tz
              hour12：否，
              年份：'数字'，月份：'两位数'，日期：'两位数'，
              小时：两位数，分钟：两位数，秒：两位数
            });
            const parts = dtf.formatToParts(now);
            const get = type => Number(parts.find(x => x.type === type).value);
            const target = Date.UTC(get('year'), get('month') - 1, get('day'), get('hour'), get('minute'), get('second'));
            const utc = now.getTime();
            const offset = Math.round((target - utc) / (1000 * 60 * 60));
            
            // 时区中文名称地图
            const timezoneNames = {
              'UTC': '世界标准时间',
              '亚洲/上海': '中国标准时间',
              'Asia/Hong_Kong': '香港时间',
              '亚洲/台北': '台北时间',
              '亚洲/新加坡': '新加坡时间',
              '亚洲/东京': '日本时间',
              '亚洲/首尔': '韩国时间',
              'America/New_York': '美国东部时间',
              'America/Los_Angeles': '美国太平洋时间',
              'America/Chicago': '美国中部时间',
              'America/Denver': '美国山地时间',
              '欧洲/伦敦': '英国时间',
              '欧洲/巴黎': '巴黎时间',
              'Europe/Berlin': '柏林时间',
              '欧洲/莫斯科': '莫斯科时间',
              '澳大利亚/悉尼': '悉尼时间',
              '澳大利亚/墨尔本': '墨尔本时间',
              “太平洋/奥克兰”：“奥克兰时间”
            };
            
            const offsetStr = offset >= 0 ? '+' + offset : offset;
            const timezoneName = timezoneNames[tz] || tz;
            返回 timezoneName + ' (UTC' + offsetStr + ')';
          } catch (error) {
            console.error('格式化时区显示失败:', error);
            返回 tz；
          }
        }
        函数 update() {
          const now = new Date();
          const timeStr = formatTime(now, globalTimezone);
          const tzStr = formatTimezoneDisplay(globalTimezone);
          const el = document.getElementById('systemTimeDisplay');
          如果 (el) {
            el.textContent = timeStr + ' ' + tzStr;
          }
        }
        更新（）;
        // 每秒刷新
        设置更新间隔为 1000。
        
        //定期检查时区变化并重新加载订阅列表（每30秒检查一次）
        setInterval(async () => {
          尝试 {
            const response = await fetch('/api/config');
            const config = await response.json();
            const newTimezone = config.TIMEZONE || '世界标准时间';
            
            if (globalTimezone !== newTimezone) {
              globalTimezone = newTimezone;
              console.log('时区已更新为:', globalTimezone);
              // 重新加载订阅列表以更新天数计算
              加载订阅();
            }
          } catch (error) {
            console.error('检查时区更新失败:', error);
          }
        }, 30000);
        
        // 初始加载订阅列表
        加载订阅();
      } catch (e) {
        // 错误时显示本地时间
        const el = document.getElementById('systemTimeDisplay');
        如果 (el) {
          el.textContent = new Date().toLocaleString();
        }
      }
    }
    显示系统时间();
  </script>
</body>
</html>
`;

const configPage = `
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>系统配置-订阅管理系统</title>
  <link href="https://cdn.jsdelivr.net/npm/tailwindcss@2.2.19/dist/tailwind.min.css" rel="stylesheet">
  <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0-beta3/css/all.min.css" rel="stylesheet">
  <style>
    .btn-primary { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); transition: all 0.3s; }
    .btn-primary:hover { transform: translateY(-2px); box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1); }
    .btn-secondary { background: linear-gradient(135deg, #6b7280 0%, #4b5563 100%); transition: all 0.3s; }
    .btn-secondary:hover { transform: translateY(-2px); box-shadow: 0 5px 15px rgba(0, 0, 0, 0.1); }
    
    .toast {
      position: fixed; top: 20px; right: 20px; padding: 12px 20px; border-radius: 8px;
      颜色：白色；字体粗细：500；z轴索引：1000；变换：translateX(400px)；
      transition: all 0.3s ease-in-out; box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
    }
    .toast.show { transform: translateX(0); }
    .toast.success { background-color: #10b981; }
    .toast.error { background-color: #ef4444; }
    .toast.info { background-color: #3b82f6; }
    .toast.warning { background-color: #f59e0b; }
    
    .config-section {
      border: 1px solid #e5e7eb;
      圆角半径：8px；
      内边距：16px；
      margin-bottom: 24px;
    }
    .config-section.active {
      背景颜色：#f8fafc；
      边框颜色：#6366f1；
    }
    .config-section.inactive {
      背景颜色：#f9fafb；
      不透明度：0.7；
    }
  </style>
</head>
<body class="bg-gray-100 min-h-screen">
  <div id="toast-container"></div>

  <nav class="bg-white shadow-md">
    <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
      <div class="flex justify-between h-16">
        <div class="flex items-center">
          <i class="fas fa-calendar-check text-indigo-600 text-2xl mr-2"></i>
          <span class="font-bold text-xl text-gray-800">订阅管理系统</span>
          <span id="systemTimeDisplay" class="ml-4 text-base text-indigo-600 font-normal"></span>
        </div>
        <div class="flex items-center space-x-4">
          <a href="/admin" class="text-gray-700 hover:text-gray-900 px-3 py-2 rounded-md text-sm font-medium">
            <i class="fas fa-list mr-1"></i>订阅列表
          </a>
          <a href="/admin/config" class="text-indigo-600 border-b-2 border-indigo-600 px-3 py-2 rounded-md text-sm font-medium">
            <i class="fas fa-cog mr-1"></i>系统配置
          </a>
          <a href="/api/logout" class="text-gray-700 hover:text-gray-900 px-3 py-2 rounded-md text-sm font-medium">
            <i class="fas fa-sign-out-alt mr-1"></i>退出登录
          </a>
        </div>
      </div>
    </div>
  </nav>
  
  <div class="max-w-4xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
    <div class="bg-white rounded-lg shadow-md p-6">
      <h2 class="text-2xl font-bold text-gray-800 mb-6">系统配置</h2>
      
      <form id="configForm" class="space-y-8">
        <div class="border-b border-gray-200 pb-6">
          <h3 class="text-lg font-medium text-gray-900 mb-4">管理员账户</h3>
          <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
            <div>
              <label for="adminUsername" class="block text-sm font-medium text-gray-700">用户名</label>
              <input type="text" id="adminUsername" class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
            </div>
            <div>
              <label for="adminPassword" class="block text-sm font-medium text-gray-700">密码</label>
              <input type="password" id="adminPassword" placeholder="如不修改密码，请留空" class="mt-1 block w-full border border-gray-300 rounded-md Shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
              <p class="mt-1 text-sm text-gray-500">留空表示不修改当前密码</p>
            </div>
          </div>
        </div>
        
        <div class="border-b border-gray-200 pb-6">
          <h3 class="text-lg font-medium text-gray-900 mb-4">显示设置</h3>
          
          
          <div class="mb-6">
            <label class="inline-flex items-center">
              <input type="checkbox" id="showLunarGlobal" class="form-checkbox h-4 w-4 text-indigo-600 border-gray-300 rounded focus:ring-indigo-500" checked>
              <span class="ml-2 text-sm text-gray-700">在通知中显示农历日期</span>
            </label>
            <p class="mt-1 text-sm text-gray-500">控制通知消息中是否包含农历日期信息</p>
          </div>
        </div>


        <div class="border-b border-gray-200 pb-6">
          <h3 class="text-lg font-medium text-gray-900 mb-4">时区设置</h3>
          <div class="mb-6">
          <label for="timezone" class="block text-sm font-medium text-gray-700 mb-1">时区选择</label>
          <select id="timezone" name="timezone" class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 bg-white">
            <option value="UTC">世界标准时间（UTC+0）</option>
            <option value="Asia/Shanghai">中国标准时间（UTC+8）</option>
            <option value="Asia/Hong_Kong">香港时间（UTC+8）</option>
            <option value="Asia/Taipei">台北时间（UTC+8）</option>
            <option value="Asia/Singapore">新加坡时间（UTC+8）</option>
            <option value="Asia/Tokyo">日本时间（UTC+9）</option>
            <option value="Asia/Seoul">韩国时间（UTC+9）</option>
            <option value="America/New_York">美国东部时间（UTC-5）</option>
            <option value="America/Chicago">美国中部时间（UTC-6）</option>
            <option value="America/Denver">美国山地时间（UTC-7）</option>
            <option value="America/Los_Angeles">美国太平洋时间（UTC-8）</option>
            <option value="Europe/London">英国时间（UTC+0）</option>
            <option value="Europe/Paris">巴黎时间（UTC+1）</option>
            <option value="Europe/Berlin">柏林时间（UTC+1）</option>
            <option value="Europe/Moscow">莫斯科时间（UTC+3）</option>
            <option value="Australia/Sydney">悉尼时间（UTC+10）</option>
            <option value="Australia/Melbourne">墨尔本时间（UTC+10）</option>
            <option value="Pacific/Auckland">奥克兰时间（UTC+12）</option>
          </select>
            <p class="mt-1 text-sm text-gray-500">选择需要使用时区，系统会按该时区计算剩余时间（提醒 Cron 仍基于 UTC，请在 Cloudflare 控制台换算触发时间）</p>
          </div>
        </div>

        
        <div class="border-b border-gray-200 pb-6">
          <h3 class="text-lg font-medium text-gray-900 mb-4">通知设置</h3>
          <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mb-6">
            <div>
              <label for="notificationHours" class="block text-sm font-medium text-gray-700">通知积分（UTC）</label>
              <input type="text" id="notificationHours" placeholder="例如：08, 12, 20 或输入 * 表示全天"
                class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
              <p class="mt-1 text-sm text-gray-500">可输入多个小时，使用逗号或空格分隔；留空则默认每天执行一次任务即可</p>
            </div>
            <div class="bg-indigo-50 border border-indigo-100 rounded-md p-3 text-sm text-indigo-700">
              <p class="font-medium mb-1">提示</p>
              <p>Cloudflare Workers Cron 以 UTC 计算，例如北京时间 08:00 需设置 Cron 为 <code>0 0 * * *</code> 并在此填入 08。</p>
              <p class="mt-1">若 Cron 已设置为底部执行，可用该字段限制实际发送提醒的小时段。</p>
            </div>
          </div>
          <div class="mb-6">
            <label class="block text-sm font-medium text-gray-700 mb-3">通知方式（可多选）</label>
            <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
              <label class="inline-flex items-center">
                <input type="checkbox" name="enabledNotifiers" value="telegram" class="form-checkbox h-4 w-4 text-indigo-600 border-gray-300 rounded focus:ring-indigo-500">
                <span class="ml-2 text-sm text-gray-700">Telegram</span>
              </label>
              <label class="inline-flex items-center">
                <input type="checkbox" name="enabledNotifiers" value="notifyx" class="form-checkbox h-4 w-4 text-indigo-600 border-gray-300 rounded focus:ring-indigo-500" checked>
                <span class="ml-2 text-sm text-gray-700 font-semibold">NotifyX</span>
              </label>
              <label class="inline-flex items-center">
                <input type="checkbox" name="enabledNotifiers" value="webhook" class="form-checkbox h-4 w-4 text-indigo-600 border-gray-300 rounded focus:ring-indigo-500">
                <span class="ml-2 text-sm text-gray-700">Webhook 通知</span>
              </label>
              <label class="inline-flex items-center">
                <input type="checkbox" name="enabledNotifiers" value="wechatbot" class="form-checkbox h-4 w-4 text-indigo-600 border-gray-300 rounded focus:ring-indigo-500">
                <span class="ml-2 text-sm text-gray-700">企业微信机器人</span>
              </label>
              <label class="inline-flex items-center">
                <input type="checkbox" name="enabledNotifiers" value="email" class="form-checkbox h-4 w-4 text-indigo-600 border-gray-300 rounded focus:ring-indigo-500">
                <span class="ml-2 text-sm text-gray-700">邮件通知</span>
              </label>
              <label class="inline-flex items-center">
                <input type="checkbox" name="enabledNotifiers" value="bark" class="form-checkbox h-4 w-4 text-indigo-600 border-gray-300 rounded focus:ring-indigo-500">
                <span class="ml-2 text-sm text-gray-700">树皮</span>
              </label>
            </div>
            <div class="mt-2 flex flex-wrap gap-4">
              <a href="https://www.notifyx.cn/" target="_blank" class="text-indigo-600 hover:text-indigo-800 text-sm">
                <i class="fas fa-external-link-alt ml-1"></i> NotifyX 官网
              </a>
              <a href="https://webhook.site" target="_blank" class="text-indigo-600 hover:text-indigo-800 text-sm">
                <i class="fas fa-external-link-alt ml-1"></i> Webhook 调试工具
              </a>
              <a href="https://developer.work.weixin.qq.com/document/path/91770" target="_blank" class="text-indigo-600 hover:text-indigo-800 text-sm">
                <i class="fas fa-external-link-alt ml-1"></i> 企业微信机器人文档
              </a>
              <a href="https://developers.cloudflare.com/workers/tutorials/send-emails-with-resend/" target="_blank" class="text-indigo-600 hover:text-indigo-800 text-sm">
                <i class="fas fa-external-link-alt ml-1"></i> 获取重新发送 API 密钥
              </a>
              <a href="https://apps.apple.com/cn/app/bark-customed-notifications/id1403753865" target="_blank" class="text-indigo-600 hover:text-indigo-800 text-sm">
                <i class="fas fa-external-link-alt ml-1"></i> Bark iOS应用
              </a>
            </div>
          </div>

          <div class="mb-6">
            <label for="thirdPartyToken" class="block text-sm font-medium text-gray-700">第三方 API 访问令牌</label>
            <div class="mt-1 flex flex-col sm:flex-row sm:items-center gap-3">
              <input type="text" id="thirdPartyToken" placeholder="建议使用随机字符串，例如：iH5s9vB3..."
                class="flex-1 border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
              <button type="button" id="generateThirdPartyToken" class="btn-info text-white px-4 py-2 rounded-md text-sm font-medium whitespace-nowrap">
                <i class="fas fa-magic mr-2"></i>生成令牌
              </button>
            </div>
            <p class="mt-1 text-sm text-gray-500"> /api/notify/{token} 接口时需调用此令牌；留空表示取消第三方API。</p>
          </div>
          
          <div id="telegramConfig" class="config-section">
            <h4 class="text-md font-medium text-gray-900 mb-3">Telegram 配置</h4>
            <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mb-4">
              <div>
                <label for="tgBotToken" class="block text-sm font-medium text-gray-700">机器人令牌</label>
                <input type="text" id="tgBotToken" placeholder="从 @BotFather 获取" class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
              </div>
              <div>
                <label for="tgChatId" class="block text-sm font-medium text-gray-700">聊天 ID</label>
                <input type="text" id="tgChatId" placeholder="可从 @userinfobot 获取" class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
              </div>
            </div>
            <div class="flex justify-end">
              <button type="button" id="testTelegramBtn" class="btn-secondary text-white px-4 py-2 rounded-md text-sm font-medium">
                <i class="fas fa-paper-plane mr-2"></i>测试 Telegram 通知
              </button>
            </div>
          </div>
          
          <div id="notifyxConfig" class="config-section">
            <h4 class="text-md font-medium text-gray-900 mb-3">NotifyX 配置</h4>
            <div class="mb-4">
              <label for="notifyxApiKey" class="block text-sm font-medium text-gray-700">API 密钥</label>
              <input type="text" id="notifyxApiKey" placeholder="从NotifyX平台获取的API Key" class="mt-1 block w-full border border-gray-300 rounded-md Shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
              <p class="mt-1 text-sm text-gray-500">从<a href="https://www.notifyx.cn/" target="_blank" class="text-indigo-600 hide:text-indigo-800">NotifyX平台</a>获取的API Key</p>
            </div>
            <div class="flex justify-end">
              <button type="button" id="testNotifyXBtn" class="btn-secondary text-white px-4 py-2 rounded-md text-sm font-medium">
                <i class="fas fa-paper-plane mr-2"></i>测试 NotifyX 通知
              </button>
            </div>
          </div>

          <div id="webhookConfig" class="config-section">
            <h4 class="text-md font-medium text-gray-900 mb-3">Webhook 通知配置</h4>
            <div class="grid grid-cols-1 gap-4 mb-4">
              <div>
                <label for="webhookUrl" class="block text-sm font-medium text-gray-700">Webhook 通知 URL</label>
                <input type="url" id="webhookUrl" placeholder="https://your-webhook-endpoint.com/path" class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
                <p class="mt-1 text-sm text-gray-500">请填写自建服务或第三方平台提供的Webhook地址，例如<code>https://your-webhook-endpoint.com/path</code></p>
              </div>
              <div>
                <label for="webhookMethod" class="block text-sm font-medium text-gray-700">请求方法</label>
                <select id="webhookMethod" class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
                  <option value="POST">POST</option>
                  <option value="GET">获取</option>
                  <option value="PUT">PUT</option>
                </select>
              </div>
              <div>
                <label for="webhookHeaders" class="block text-sm font-medium text-gray-700">自定义请求头 (JSON格式，任选)</label>
                <textarea id="webhookHeaders" rows="3" placeholder='{"Authorization": "Bearer your-token", "Content-Type": "application/json"}' class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm"></textarea>
                <p class="mt-1 text-sm text-gray-500">JSON格式的自定义请求头，留空使用默认</p>
              </div>
              <div>
                <label for="webhookTemplate" class="block text-sm font-medium text-gray-700">消息模板 (JSON格式，任选)</label>
                <textarea id="webhookTemplate" rows="4" placeholder='{"title": "{{title}}", "content": "{{content}}", "timestamp": "{{timestamp}}"}' class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm"></textarea>
                <p class="mt-1 text-sm text-gray-500">支持变量: {{title}}, {{content}}, {{timestamp}}。留空使用默认格式</p>
              </div>
            </div>
            <div class="flex justify-end">
              <button type="button" id="testWebhookBtn" class="btn-secondary text-white px-4 py-2 rounded-md text-sm font-medium">
                <i class="fas fa-paper-plane mr-2"></i>测试 Webhook 通知
              </button>
            </div>
          </div>

          <div id="wechatbotConfig" class="config-section">
            <h4 class="text-md font-medium text-gray-900 mb-3">企业微信机器人配置</h4>
            <div class="grid grid-cols-1 gap-4 mb-4">
              <div>
                <label for="wechatbotWebhook" class="block text-sm font-medium text-gray-700">机器人 Webhook URL</label>
                <input type="url" id="wechatbotWebhook" placeholder="https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=your-key" class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
                <p class="mt-1 text-sm text-gray-500">从企业微信群聊中添加机器人获取的Webhook URL</p>
              </div>
              <div>
                <label for="wechatbotMsgType" class="block text-sm font-medium text-gray-700">消息类型</label>
                <select id="wechatbotMsgType" class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
                  <option value="text">文本消息</option>
                  <option value="markdown">Markdown 消息</option>
                </select>
                <p class="mt-1 text-sm text-gray-500">选择发送的消息格式类型</p>
              </div>
              <div>
                <label for="wechatbotAtMobiles" class="block text-sm font-medium text-gray-700">@手机号 (任选)</label>
                <input type="text" id="wechatbotAtMobiles" placeholder="13800138000,13900139000" class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
                <p class="mt-1 text-sm text-gray-500">需要@的手机号，多个用分隔符分隔，留空则不@任何人</p>
              </div>
              <div>
                <label for="wechatbotAtAll" class="block text-sm font-medium text-gray-700 mb-2">@所有人</label>
                <label class="inline-flex items-center">
                  <input type="checkbox" id="wechatbotAtAll" class="form-checkbox h-4 w-4 text-indigo-600 border-gray-300 rounded focus:ring-indigo-500">
                  <span class="ml-2 text-sm text-gray-700">发送消息时@所有者</span>
                </label>
              </div>
            </div>
            <div class="flex justify-end">
              <button type="button" id="testWechatBotBtn" class="btn-secondary text-white px-4 py-2 rounded-md text-sm font-medium">
                <i class="fas fa-paper-plane mr-2"></i>测试企业微信机器人
              </button>
            </div>
          </div>

          <div id="emailConfig" class="config-section">
            <h4 class="text-md font-medium text-gray-900 mb-3">邮件通知配置</h4>
            <div class="grid grid-cols-1 gap-4 mb-4">
              <div>
                <label for="resendApiKey" class="block text-sm font-medium text-gray-700">重新发送 API 密钥</label>
                <input type="text" id="resendApiKey" placeholder="re_xxxxxxxxxx" class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
                <p class="mt-1 text-sm text-gray-500">从<a href="https://resend.com/api-keys" target="_blank" class="text-indigo-600 hide:text-indigo-800">重新发送控制台</a>获取API密钥</p>
              </div>
              <div>
                <label for="emailFrom" class="block text-sm font-medium text-gray-700">发件人邮箱</label>
                <input type="email" id="emailFrom" placeholder="noreply@yourdomain.com" class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
                <p class="mt-1 text-sm text-gray-500">必须已在重新发送验证的域名邮箱</p>
              </div>
              <div>
                <label for="emailFromName" class="block text-sm font-medium text-gray-700">发件人名称</label>
                <input type="text" id="emailFromName" placeholder="订阅提醒系统" class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
                <p class="mt-1 text-sm text-gray-500">在邮件中显示发件人名</p>
              </div>
              <div>
                <label for="emailTo" class="block text-sm font-medium text-gray-700">职业邮箱</label>
                <input type="email" id="emailTo" placeholder="user@example.com" class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
                <p class="mt-1 text-sm text-gray-500">接收通知邮件的邮箱地址</p>
              </div>
            </div>
            <div class="flex justify-end">
              <button type="button" id="testEmailBtn" class="btn-secondary text-white px-4 py-2 rounded-md text-sm font-medium">
                <i class="fas fa-paper-plane mr-2"></i>测试邮件通知
              </button>
            </div>
          </div>

          <div id="barkConfig" class="config-section">
            <h4 class="text-md font-medium text-gray-900 mb-3">Bark 配置</h4>
            <div class="grid grid-cols-1 gap-4 mb-4">
              <div>
                <label for="barkServer" class="block text-sm font-medium text-gray-700"> 服务器地址</label>
                <input type="url" id="barkServer" placeholder="https://api.day.app" class="mt-1 block w-full border border-gray-300 rounded-md shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
                <p class="mt-1 text-sm text-gray-500">Bark服务器地址，默认为官方服务器，也可以使用自建服务器</p>
              </div>
              <div>
                <label for="barkDeviceKey" class="block text-sm font-medium text-gray-700">设备键</label>
                <input type="text" id="barkDeviceKey" placeholder="从Bark应用获取的设备Key" class="mt-1 block w-full border border-gray-300 rounded-md Shadow-sm py-2 px-3 focus:outline-none focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm">
                <p class="mt-1 text-sm text-gray-500">从<a href="https://apps.apple.com/cn/app/bark-customed-notifications/id1403753865" target="_blank" class="text-indigo-600 hide:text-indigo-800">Bark iOS应用</a>中获取的设备密钥</p>
              </div>
              <div>
                <label for="barkIsArchive" class="block text-sm font-medium text-gray-700 mb-2">保存主动</label>
                <label class="inline-flex items-center">
                  <input type="checkbox" id="barkIsArchive" class="form-checkbox h-4 w-4 text-indigo-600 border-gray-300 rounded focus:ring-indigo-500">
                  <span class="ml-2 text-sm text-gray-700">保存个体到历史记录</span>
                </label>
                <p class="mt-1 text-sm text-gray-500">勾选后自动消息会保存到Bark的历史记录中</p>
              </div>
            </div>
            <div class="flex justify-end">
              <button type="button" id="testBarkBtn" class="btn-secondary text-white px-4 py-2 rounded-md text-sm font-medium">
                <i class="fas fa-paper-plane mr-2"></i>测试 Bark 通知
              </button>
            </div>
          </div>
        </div>

        <div class="flex justify-end">
          <button type="submit" class="btn-primary text-white px-6 py-2 rounded-md text-sm font-medium">
            <i class="fas fa-save mr-2"></i>保存配置
          </button>
        </div>
      </form>
    </div>
  </div>

  <script>
    function showToast(message, type = 'success', duration = 3000) {
      const container = document.getElementById('toast-container');
      const toast = document.createElement('div');
      toast.className = 'toast ' + type;
      
      const icon = type === 'success' ? 'check-circle' :
                   type === 'error' ? '感叹号' :
                   type === 'warning' ? 'exclamation-triangle' : 'info-circle';
      
      toast.innerHTML = '<div class="flex items-center"><i class="fas fa-' + icon + ' mr-2"></i><span>' + message + '</span></div>';
      
      container.appendChild(toast);
      setTimeout(() => toast.classList.add('show'), 100);
      setTimeout(() => {
        toast.classList.remove('show');
        setTimeout(() => {
          如果（容器包含（toast））{
            container.removeChild(toast);
          }
        }, 300);
      }， 期间）;
    }

    异步函数 loadConfig() {
      尝试 {
        const response = await fetch('/api/config');
        const config = await response.json();

        document.getElementById('adminUsername').value = config.ADMIN_USERNAME || '';
        document.getElementById('tgBotToken').value = config.TG_BOT_TOKEN || '';
        document.getElementById('tgChatId').value = config.TG_CHAT_ID || '';
        document.getElementById('notifyxApiKey').value = config.NOTIFYX_API_KEY || '';
        document.getElementById('webhookUrl').value = config.WEBHOOK_URL || '';
        document.getElementById('webhookMethod').value = config.WEBHOOK_METHOD || 'POST';
        document.getElementById('webhookHeaders').value = config.WEBHOOK_HEADERS || '';
        document.getElementById('webhookTemplate').value = config.WEBHOOK_TEMPLATE || '';
        document.getElementById('wechatbotWebhook').value = config.WECHATBOT_WEBHOOK || '';
        document.getElementById('wechatbotMsgType').value = config.WECHATBOT_MSG_TYPE || 'text';
        document.getElementById('wechatbotAtMobiles').value = config.WECHATBOT_AT_MOBILES || '';
        document.getElementById('wechatbotAtAll').checked = config.WECHATBOT_AT_ALL === 'true';
        document.getElementById('resendApiKey').value = config.RESEND_API_KEY || '';
        document.getElementById('emailFrom').value = config.EMAIL_FROM || '';
        document.getElementById('emailFromName').value = config.EMAIL_FROM_NAME || '订阅提醒系统';
        document.getElementById('emailTo').value = config.EMAIL_TO || '';
        document.getElementById('barkServer').value = config.BARK_SERVER || 'https://api.day.app';
        document.getElementById('barkDeviceKey').value = config.BARK_DEVICE_KEY || '';
        document.getElementById('barkIsArchive').checked = config.BARK_IS_ARCHIVE === 'true';
        document.getElementById('thirdPartyToken').value = config.THIRD_PARTY_API_TOKEN || '';
        const notificationHoursInput = document.getElementById('notificationHours');
        如果 (notificationHoursInput) {
          // 将通知几个小时整理为删除分隔的字符串，然后管理员查看与编辑
          const hours = Array.isArray(config.NOTIFICATION_HOURS) ? config.NOTIFICATION_HOURS : [];
          notificationHoursInput.value = hours.join(', ');
        }
        
        // 加载农历显示设置
        document.getElementById('showLunarGlobal').checked = config.SHOW_LUNAR === true;

        // 动态生成时区选项，并设置保存的值
        generateTimezoneOptions(config.TIMEZONE || 'UTC');

        // 处理多选通知渠道
        const enabledNotifiers = config.ENABLED_NOTIFIERS || ['notifyx'];
        document.querySelectorAll('input[name="enabledNotifiers"]').forEach(checkbox => {
          checkbox.checked = enabledNotifiers.includes(checkbox.value);
        });

        toggleNotificationConfigs(enabledNotifiers);
      } catch (error) {
        console.error('加载配置失败:', error);
        showToast('加载配置失败，请刷新页面重试', '错误');
      }
    }
    
    // 动态生成时区选项
    function generateTimezoneOptions(selectedTimezone = 'UTC') {
      const timezoneSelect = document.getElementById('timezone');
      
      const timezones = [
        { value: 'UTC', name: '世界标准时间', offset: '+0' },
        { value: '亚洲/上海', name: '中国标准时间', offset: '+8' },
        { value: 'Asia/Hong_Kong', name: '香港时间', offset: '+8' },
        { value: '亚洲/台北', name: '台北时间', offset: '+8' },
        { value: '亚洲/新加坡', name: '新加坡时间', offset: '+8' },
        { value: '亚洲/东京', name: '日本时间', offset: '+9' },
        { value: '亚洲/首尔', name: '韩国时间', offset: '+9' },
        { value: 'America/New_York', name: '美国东部时间', offset: '-5' },
        { value: 'America/Chicago', name: '美国中部时间', offset: '-6' },
        { value: '美国/丹佛', name: '美国山地时间', offset: '-7' },
        { value: 'America/Los_Angeles', name: '美国太平洋时间', offset: '-8' },
        { value: '欧洲/伦敦', name: '英国时间', offset: '+0' },
        { value: '欧洲/巴黎', name: '巴黎时间', offset: '+1' },
        { value: '欧洲/柏林', name: '柏林时间', offset: '+1' },
        { value: '欧洲/莫斯科', name: '莫斯科时间', offset: '+3' },
        { value: '澳大利亚/悉尼', name: '悉尼时间', offset: '+10' },
        { value: '澳大利亚/墨尔本', name: '墨尔本时间', offset: '+10' },
        { value: '太平洋/奥克兰', name: '奥克兰时间', offset: '+12' }
      ];
      
      // 清空现有选项
      timezoneSelect.innerHTML = '';
      
      //添加新选项
      timezones.forEach(tz => {
        const option = document.createElement('option');
        option.value = tz.value;
        option.textContent = tz.name + '（UTC' + tz.offset + '）';
        timezoneSelect.appendChild(option);
      });
      
      // 设置选中的时区
      timezoneSelect.value = selectedTimezone;
    }
    
    function toggleNotificationConfigs(enabledNotifiers) {
      const telegramConfig = document.getElementById('telegramConfig');
      const notifyxConfig = document.getElementById('notifyxConfig');
      const webhookConfig = document.getElementById('webhookConfig');
      const wechatbotConfig = document.getElementById('wechatbotConfig');
      const emailConfig = document.getElementById('emailConfig');
      const barkConfig = document.getElementById('barkConfig');

      // 重置所有配置区域
      [telegramConfig, notifyxConfig, webhookConfig, wechatbotConfig, emailConfig, barkConfig].forEach(config => {
        config.classList.remove('active', 'inactive');
        config.classList.add('inactive');
      });

      // 激活选中的配置区域
      enabledNotifiers.forEach(type => {
        如果（类型 === 'telegram'）{
          telegramConfig.classList.remove('inactive');
          telegramConfig.classList.add('active');
        } else if (type === 'notifyx') {
          notifyxConfig.classList.remove('inactive');
          notifyxConfig.classList.add('active');
        } else if (type === 'webhook') {
          webhookConfig.classList.remove('inactive');
          webhookConfig.classList.add('active');
        } else if (type === 'wechatbot') {
          wechatbotConfig.classList.remove('inactive');
          wechatbotConfig.classList.add('active');
        } else if (type === 'email') {
          emailConfig.classList.remove('inactive');
          emailConfig.classList.add('active');
        } else if (type === 'bark') {
          barkConfig.classList.remove('inactive');
          barkConfig.classList.add('active');
        }
      });
    }

    document.querySelectorAll('input[name="enabledNotifiers"]').forEach(checkbox => {
      checkbox.addEventListener('change', () => {
        const enabledNotifiers = Array.from(document.querySelectorAll('input[name="enabledNotifiers"]:checked'))
          .map(cb => cb.value);
        toggleNotificationConfigs(enabledNotifiers);
      });
    });
    
    document.getElementById('configForm').addEventListener('submit', async (e) => {
      e.preventDefault();

      const enabledNotifiers = Array.from(document.querySelectorAll('input[name="enabledNotifiers"]:checked'))
        .map(cb => cb.value);

      如果 (enabledNotifiers.length === 0) {
        showToast('请至少选择一种通知方式', '警告');
        返回;
      }

      const config = {
        ADMIN_USERNAME: document.getElementById('adminUsername').value.trim(),
        TG_BOT_TOKEN: document.getElementById('tgBotToken').value.trim(),
        TG_CHAT_ID: document.getElementById('tgChatId').value.trim(),
        NOTIFYX_API_KEY: document.getElementById('notifyxApiKey').value.trim(),
        WEBHOOK_URL: document.getElementById('webhookUrl').value.trim(),
        WEBHOOK_METHOD: document.getElementById('webhookMethod').value,
        WEBHOOK_HEADERS: document.getElementById('webhookHeaders').value.trim(),
        WEBHOOK_TEMPLATE: document.getElementById('webhookTemplate').value.trim(),
        SHOW_LUNAR: document.getElementById('showLunarGlobal').checked,
        WECHATBOT_WEBHOOK: document.getElementById('wechatbotWebhook').value.trim(),
        WECHATBOT_MSG_TYPE: document.getElementById('wechatbotMsgType').value,
        WECHATBOT_AT_MOBILES: document.getElementById('wechatbotAtMobiles').value.trim(),
        WECHATBOT_AT_ALL: document.getElementById('wechatbotAtAll').checked.toString(),
        RESEND_API_KEY: document.getElementById('resendApiKey').value.trim(),
        EMAIL_FROM: document.getElementById('emailFrom').value.trim(),
        EMAIL_FROM_NAME: document.getElementById('emailFromName').value.trim(),
        EMAIL_TO: document.getElementById('emailTo').value.trim(),
        BARK_SERVER: document.getElementById('barkServer').value.trim() || 'https://api.day.app',
        BARK_DEVICE_KEY: document.getElementById('barkDeviceKey').value.trim(),
        BARK_IS_ARCHIVE: document.getElementById('barkIsArchive').checked.toString(),
        ENABLED_NOTIFIERS：已启用的通知器，
        时区：document.getElementById('timezone').value.trim(),
        THIRD_PARTY_API_TOKEN: document.getElementById('thirdPartyToken').value.trim(),
        // 前置先行整理通知小时列表，届时仍会重新审核
        通知时间：(() => {
          const raw = document.getElementById('notificationHours').value.trim();
          如果 (!raw) {
            返回 [];
          }
          返回原始数据
            .split(/[,，\s]+/)
            .map(item => item.trim())
            .filter(item => item.length > 0);
        })()
      };

      const passwordField = document.getElementById('adminPassword');
      if (passwordField.value.trim()) {
        config.ADMIN_PASSWORD = passwordField.value.trim();
      }

      const submitButton = e.target.querySelector('button[type="submit"]');
      const originalContent = submitButton.innerHTML;
      submitButton.innerHTML = '<i class="fas fa-spinner fa-spin mr-2"></i>保存中...';
      submitButton.disabled = true;

      尝试 {
        const response = await fetch('/api/config', {
          方法：'POST'，
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify(config)
        });

        const result = await response.json();

        如果 (结果成功) {
          showToast('配置保存成功', '成功');
          passwordField.value = '';
          
          // 更新全局时区并重新显示时间
          globalTimezone = config.TIMEZONE;
          显示系统时间();
          
          // 标记时区已更新，提供其他页面检测
          localStorage.setItem('timezoneUpdated', Date.now().toString());
          
          // 如果当前在订阅列表页面，则自动刷新页面以更新时区显示
          如果 (window.location.pathname === '/admin') {
            window.location.reload();
          }
        } 别的 {
          showToast('配置保存失败: ' + (result.message || '未知错误'), '错误');
        }
      } catch (error) {
        console.error('保存配置失败:', error);
        showToast('保存配置失败，请稍后再试', '错误');
      } 最后 {
        submitButton.innerHTML = originalContent;
        submitButton.disabled = false;
      }
    });
    
    异步函数 testNotification(type) {
      const buttonId = type === 'telegram' ? 'testTelegramBtn' :
                      类型 === 'notifyx' ？ 'testNotifyXBtn'：
                      输入==='微信机器人'？ 'testWechatBotBtn'：
                      type === 'email' ? 'testEmailBtn' :
                      类型 === '吠' ? 'testBarkBtn' : 'testWebhookBtn';
      const button = document.getElementById(buttonId);
      const OriginalContent = Button.innerHTML;
      const serviceName = type === 'telegram' ? 'Telegram' :
                          type === 'notifyx' ? 'NotifyX' :
                          输入==='微信机器人'？ ‘企业微信机器人’：
                          输入==='电子邮件'？ ‘邮件通知’：
                          类型 === '吠' ? 'Bark' : 'Webhook 通知';

      button.innerHTML = '<i class="fas fa-spinner fa-spin mr-2"></i>测试中...';
      按钮已禁用 = true;

      const config = {};
      如果（类型 === 'telegram'）{
        config.TG_BOT_TOKEN = document.getElementById('tgBotToken').value.trim();
        config.TG_CHAT_ID = document.getElementById('tgChatId').value.trim();

        如果 (!config.TG_BOT_TOKEN || !config.TG_CHAT_ID) {
          showToast('请先填写 Telegram Bot Token 和聊天 ID', '警告');
          按钮.innerHTML = 原始内容;
          按钮已禁用 = false;
          返回;
        }
      } else if (type === 'notifyx') {
        config.NOTIFYX_API_KEY = document.getElementById('notifyxApiKey').value.trim();

        如果 (!config.NOTIFYX_API_KEY) {
          showToast('请先填写NotifyX API Key', '警告');
          按钮.innerHTML = 原始内容;
          按钮已禁用 = false;
          返回;
        }
      } else if (type === 'webhook') {
        config.WEBHOOK_URL = document.getElementById('webhookUrl').value.trim();
        config.WEBHOOK_METHOD = document.getElementById('webhookMethod').value;
        config.WEBHOOK_HEADERS = document.getElementById('webhookHeaders').value.trim();
        config.WEBHOOK_TEMPLATE = document.getElementById('webhookTemplate').value.trim();

        如果 (!config.WEBHOOK_URL) {
          showToast('请先填写Webhook通知URL', '警告');
          按钮.innerHTML = 原始内容;
          按钮已禁用 = false;
          返回;
        }
      } else if (type === 'wechatbot') {
        config.WECHATBOT_WEBHOOK = document.getElementById('wechatbotWebhook').value.trim();
        config.WECHATBOT_MSG_TYPE = document.getElementById('wechatbotMsgType').value;
        config.WECHATBOT_AT_MOBILES = document.getElementById('wechatbotAtMobiles').value.trim();
        config.WECHATBOT_AT_ALL = document.getElementById('wechatbotAtAll').checked.toString();

        如果 (!config.WECHATBOT_WEBHOOK) {
          showToast('请先填写企业微信机器人Webhook URL', '警告');
          按钮.innerHTML = 原始内容;
          按钮已禁用 = false;
          返回;
        }
      } else if (type === 'email') {
        config.RESEND_API_KEY = document.getElementById('resendApiKey').value.trim();
        config.EMAIL_FROM = document.getElementById('emailFrom').value.trim();
        config.EMAIL_FROM_NAME = document.getElementById('emailFromName').value.trim();
        config.EMAIL_TO = document.getElementById('emailTo').value.trim();

        如果 (!config.RESEND_API_KEY || !config.EMAIL_FROM || !config.EMAIL_TO) {
          showToast('请先填写 重新发送API Key、发件人邮箱和食谱邮箱', '警告');
          按钮.innerHTML = 原始内容;
          按钮已禁用 = false;
          返回;
        }
      } else if (type === 'bark') {
        config.BARK_SERVER = document.getElementById('barkServer').value.trim() || 'https://api.day.app';
        config.BARK_DEVICE_KEY = document.getElementById('barkDeviceKey').value.trim();
        config.BARK_IS_ARCHIVE = document.getElementById('barkIsArchive').checked.toString();

        如果 (!config.BARK_DEVICE_KEY) {
          showToast('请先填写 Bark 设备Key', '警告');
          按钮.innerHTML = 原始内容;
          按钮已禁用 = false;
          返回;
        }
      }

      尝试 {
        const response = await fetch('/api/test-notification', {
          方法：'POST'，
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({ type: type, ...config })
        });

        const result = await response.json();

        如果 (结果成功) {
          showToast(serviceName + '通知测试成功！', '成功');
        } 别的 {
          showToast(serviceName + '通知测试失败:' + (result.message || '未知错误'), 'error');
        }
      } catch (error) {
        console.error('测试通知失败:', error);
        showToast('测试失败，请稍后再试', 'error');
      } 最后 {
        按钮.innerHTML = 原始内容;
        按钮已禁用 = false;
      }
    }
    
    document.getElementById('testTelegramBtn').addEventListener('click', () => {
      testNotification('telegram');
    });
    
    document.getElementById('testNotifyXBtn').addEventListener('click', () => {
      testNotification('notifyx');
    });

    document.getElementById('testWebhookBtn').addEventListener('click', () => {
      testNotification('webhook');
    });

    document.getElementById('testWechatBotBtn').addEventListener('click', () => {
      testNotification('微信机器人');
    });

    document.getElementById('testEmailBtn').addEventListener('click', () => {
      testNotification('email');
    });

    document.getElementById('testBarkBtn').addEventListener('click', () => {
      testNotification('bark');
    });

    document.getElementById('generateThirdPartyToken').addEventListener('click', () => {
      尝试 {
        // 生成32位随机令牌，避免出现特殊字符，方便写入URL
        const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
        const buffer = new Uint8Array(32);
        window.crypto.getRandomValues(buffer);
        const token = Array.from(buffer).map(v => charset[v % charset.length]).join('');
        const input = document.getElementById('thirdPartyToken');
        输入值 = token；
        input.dispatchEvent(new Event('input'));
        showToast('已生成新的第三方API令牌，请保存配置后生效', 'info');
      } catch (error) {
        console.error('生成令牌失败:', error);
        showToast('生成令牌失败，请手动输入', '错误');
      }
    });

    window.addEventListener('load', loadConfig);
    
    // 全局时区配置
    let globalTimezone = 'UTC';
    
    // 实时显示系统时间和时区
    异步函数 showSystemTime() {
      尝试 {
        // 获取后台配置的时区
        const response = await fetch('/api/config');
        const config = await response.json();
        globalTimezone = config.TIMEZONE || 'UTC';
        
        // 删除当前时间
        function formatTime(dt, tz) {
          return dt.toLocaleString('zh-CN', { timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit' });
        }
        function formatTimezoneDisplay(tz) {
          尝试 {
            // 使用更准确的时区偏移计算方法
            const now = new Date();
            const dtf = new Intl.DateTimeFormat('en-US', {
              时区：tz
              hour12：否，
              年份：'数字'，月份：'两位数'，日期：'两位数'，
              小时：两位数，分钟：两位数，秒：两位数
            });
            const parts = dtf.formatToParts(now);
            const get = type => Number(parts.find(x => x.type === type).value);
            const target = Date.UTC(get('year'), get('month') - 1, get('day'), get('hour'), get('minute'), get('second'));
            const utc = now.getTime();
            const offset = Math.round((target - utc) / (1000 * 60 * 60));
            
            // 时区中文名称地图
            const timezoneNames = {
              'UTC': '世界标准时间',
              '亚洲/上海': '中国标准时间',
              'Asia/Hong_Kong': '香港时间',
              '亚洲/台北': '台北时间',
              '亚洲/新加坡': '新加坡时间',
              '亚洲/东京': '日本时间',
              '亚洲/首尔': '韩国时间',
              'America/New_York': '美国东部时间',
              'America/Los_Angeles': '美国太平洋时间',
              'America/Chicago': '美国中部时间',
              'America/Denver': '美国山地时间',
              '欧洲/伦敦': '英国时间',
              '欧洲/巴黎': '巴黎时间',
              'Europe/Berlin': '柏林时间',
              '欧洲/莫斯科': '莫斯科时间',
              '澳大利亚/悉尼': '悉尼时间',
              '澳大利亚/墨尔本': '墨尔本时间',
              “太平洋/奥克兰”：“奥克兰时间”
            };
            
            const offsetStr = offset >= 0 ? '+' + offset : offset;
            const timezoneName = timezoneNames[tz] || tz;
            返回 timezoneName + ' (UTC' + offsetStr + ')';
          } catch (error) {
            console.error('格式化时区显示失败:', error);
            返回 tz；
          }
        }
        函数 update() {
          const now = new Date();
          const timeStr = formatTime(now, globalTimezone);
          const tzStr = formatTimezoneDisplay(globalTimezone);
          const el = document.getElementById('systemTimeDisplay');
          如果 (el) {
            el.textContent = timeStr + ' ' + tzStr;
          }
        }
        更新（）;
        // 每秒刷新
        设置更新间隔为 1000。
        
        //定期检查时区变化并重新加载订阅列表（每30秒检查一次）
        setInterval(async () => {
          尝试 {
            const response = await fetch('/api/config');
            const config = await response.json();
            const newTimezone = config.TIMEZONE || '世界标准时间';
            
            if (globalTimezone !== newTimezone) {
              globalTimezone = newTimezone;
              console.log('时区已更新为:', globalTimezone);
              // 重新加载订阅列表以更新天数计算
              加载订阅();
            }
          } catch (error) {
            console.error('检查时区更新失败:', error);
          }
        }, 30000);
      } catch (e) {
        // 错误时显示本地时间
        const el = document.getElementById('systemTimeDisplay');
        如果 (el) {
          el.textContent = new Date().toLocaleString();
        }
      }
    }
    显示系统时间();
  </script>
</body>
</html>
`;

// 管理页面
// 与前端一致的分类切割则，用于提取标签信息
const CATEGORY_SEPARATOR_REGEX = /[\/,，\s]+/;

function extractTagsFromSubscriptions(subscriptions = []) {
  const tagSet = new Set();
  (subscriptions || []).forEach(sub => {
    如果 (!sub || typeof sub !== 'object') {
      返回;
    }
    如果 (Array.isArray(sub.tags)) {
      sub.tags.forEach(tag => {
        如果 (typeof tag === 'string' && tag.trim().length > 0) {
          tagSet.add(tag.trim());
        }
      });
    }
    如果 (子类别类型 === '字符串') {
      sub.category.split(CATEGORY_SEPARATOR_REGEX)
        .map(tag => tag.trim())
        .filter(tag => tag.length > 0)
        .forEach(tag => tagSet.add(tag));
    }
    如果 (typeof sub.customType === 'string' && sub.customType.trim().length > 0) {
      tagSet.add(sub.customType.trim());
    }
  });
  返回 Array.from(tagSet);
}

const admin = {
  async handleRequest(request, env, ctx) {
    尝试 {
      const url = new URL(request.url);
      const pathname = url.pathname;

      console.log('[管理页面]访问路径:', 路径名);

      const token = getCookieValue(request.headers.get('Cookie'), 'token');
      console.log('[管理页面] Token存在:', !!token);

      const config = await getConfig(env);
      const user = token ? await verifyJWT(token, config.JWT_SECRET) : null;

      console.log('[管理页面]用户验证结果:', !!user);

      如果 (!user) {
        console.log('[管理页面]用户未登录，重定向到登录页面');
        返回新的 Response('', {
          状态：302
          headers: { 'Location': '/' }
        });
      }

      如果 (pathname === '/admin/config') {
        返回新的 Response(configPage, {
          headers: { 'Content-Type': 'text/html; charset=utf-8' }
        });
      }

      返回新的 Response(adminPage, {
        headers: { 'Content-Type': 'text/html; charset=utf-8' }
      });
    } catch (error) {
      console.error('[管理页面]处理请求时错误:', error);
      return new Response('服务器内部错误', {
        状态：500
        headers: { 'Content-Type': 'text/plain; charset=utf-8' }
      });
    }
  }
};

// 处理API请求
const api = {
  async handleRequest(request, env, ctx) {
    const url = new URL(request.url);
    const path = url.pathname.slice(4);
    const method = request.method;

    const config = await getConfig(env);

    如果 (路径 === '/login' && 方法 === 'POST') {
      const body = await request.json();

      如果 (body.username === config.ADMIN_USERNAME && body.password === config.ADMIN_PASSWORD) {
        const token = await generateJWT(body.username, config.JWT_SECRET);

        返回新的响应(
          JSON.stringify({ success: true }),
          {
            标题：{
              'Content-Type': 'application/json',
              'Set-Cookie': 'token=' + token + '; HttpOnly; Path=/; SameSite=Strict; Max-Age=86400'
            }
          }
        ）；
      } 别的 {
        返回新的响应(
          JSON.stringify({ success: false, message: '用户名或密码错误' }),
          { headers: { 'Content-Type': 'application/json' } }
        ）；
      }
    }

    如果 (路径 === '/logout' && (方法 === 'GET' || 方法 === 'POST')) {
      返回新的 Response('', {
        状态：302
        标题：{
          '地点'： '/'，
          'Set-Cookie': 'token=; HttpOnly; Path=/; SameSite=Strict; Max-Age=0'
        }
      });
    }

    const token = getCookieValue(request.headers.get('Cookie'), 'token');
    const user = token ? await verifyJWT(token, config.JWT_SECRET) : null;

    如果 (!user && path !== '/login') {
      返回新的响应(
        JSON.stringify({ success: false, message: '未授权访问' }),
        { status: 401, headers: { 'Content-Type': 'application/json' } }
      ）；
    }

    如果 (路径 === '/config') {
      如果 (方法 === 'GET') {
        const { JWT_SECRET, ADMIN_PASSWORD, ...safeConfig } = config;
        返回新的响应(
          JSON.stringify(safeConfig),
          { headers: { 'Content-Type': 'application/json' } }
        ）；
      }

      如果 (方法 === 'POST') {
        尝试 {
          const newConfig = await request.json();

          const updatedConfig = {
            ...配置，
            ADMIN_USERNAME: newConfig.ADMIN_USERNAME || config.ADMIN_USERNAME,
            TG_BOT_TOKEN：newConfig.TG_BOT_TOKEN || '',
            TG_CHAT_ID：newConfig.TG_CHAT_ID || '',
            NOTIFYX_API_KEY: newConfig.NOTIFYX_API_KEY || '',
            WEBHOOK_URL：newConfig.WEBHOOK_URL || '',
            WEBHOOK_METHOD: newConfig.WEBHOOK_METHOD || 'POST',
            WEBHOOK_HEADERS: newConfig.WEBHOOK_HEADERS || '',
            WEBHOOK_TEMPLATE: newConfig.WEBHOOK_TEMPLATE || '',
            SHOW_LUNAR：newConfig.SHOW_LUNAR === true，
            WECHATBOT_WEBHOOK：newConfig.WECHATBOT_WEBHOOK || '',
            WECHATBOT_MSG_TYPE：newConfig.WECHATBOT_MSG_TYPE || '文本'，
            WECHATBOT_AT_MOBILES：newConfig.WECHATBOT_AT_MOBILES || '',
            WECHATBOT_AT_ALL：newConfig.WECHATBOT_AT_ALL || '错误的'，
            RESEND_API_KEY: newConfig.RESEND_API_KEY || '',
            EMAIL_FROM: newConfig.EMAIL_FROM || '',
            EMAIL_FROM_NAME: newConfig.EMAIL_FROM_NAME || '',
            EMAIL_TO：newConfig.EMAIL_TO || '',
            BARK_DEVICE_KEY: newConfig.BARK_DEVICE_KEY || '',
            BARK_SERVER: newConfig.BARK_SERVER || 'https://api.day.app',
            BARK_IS_ARCHIVE: newConfig.BARK_IS_ARCHIVE || 'false',
            ENABLED_NOTIFIERS: newConfig.ENABLED_NOTIFIERS || ['notifyx'],
            时区：newConfig.TIMEZONE || config.TIMEZONE || '世界标准时间'，
            THIRD_PARTY_API_TOKEN: newConfig.THIRD_PARTY_API_TOKEN || ''
          };

          const rawNotificationHours = Array.isArray(newConfig.NOTIFICATION_HOURS)
            ? newConfig.NOTIFICATION_HOURS
            newConfig.NOTIFICATION_HOURS 的类型 === 'string'
              newConfig.NOTIFICATION_HOURS.split(',')
              : [];

          const sanitizedNotificationHours = rawNotificationHours
            .map(value => String(value).trim())
            .filter(value => value.length > 0)
            .map(value => {
              const upperValue = value.toUpperCase();
              如果 (upperValue === '*' || upperValue === 'ALL') {
                返回 '';
              }
              const numeric = Number(upperValue);
              如果 (!isNaN(数值)) {
                return String(Math.max(0, Math.min(23, Math.floor(numeric)))).padStart(2, '0');
              }
              返回 upperValue；
            });

          updatedConfig.NOTIFICATION_HOURS = sanitizedNotificationHours;

          如果（newConfig.ADMIN_PASSWORD）{
            updateConfig.ADMIN_PASSWORD = newConfig.ADMIN_PASSWORD;
          }

          //确保JWT_SECRET存在且安全
          if (!updatedConfig.JWT_SECRET || updatedConfig.JWT_SECRET === 'your-secret-key') {
            updatedConfig.JWT_SECRET = generateRandomSecret();
            console.log('[安全]生成新的JWT密钥');
          }

          await env.SUBSCRIPTIONS_KV.put('config', JSON.stringify(updatedConfig));

          返回新的响应(
            JSON.stringify({ success: true }),
            { headers: { 'Content-Type': 'application/json' } }
          ）；
        } catch (error) {
          console.error('配置保存错误:', error);
          返回新的响应(
            JSON.stringify({ success: false, message: '更新配置失败: ' + error.message }),
            { status: 400, headers: { 'Content-Type': 'application/json' } }
          ）；
        }
      }
    }

    如果 (路径 === '/test-notification' && 方法 === 'POST') {
      尝试 {
        const body = await request.json();
        let success = false;
        let message = '';

        如果 (body.type === 'telegram') {
          const testConfig = {
            ...配置，
            TG_BOT_TOKEN: body.TG_BOT_TOKEN,
            TG_CHAT_ID：body.TG_CHAT_ID
          };

          const content = '*测试通知*\n\n这是一条测试通知，用于验证Telegram通知功能是否正常工作。\n\n发送时间: ' + formatBeijingTime();
          success = await sendTelegramNotification(content, testConfig);
          消息=成功？ 'Telegram通知发送成功' : 'Telegram通知发送失败，请检查配置';
        } else if (body.type === 'notifyx') {
          const testConfig = {
            ...配置，
            NOTIFYX_API_KEY: body.NOTIFYX_API_KEY
          };

          const title = '测试通知';
          const content = '## 这是一条测试通知\n\n用于验证NotifyX通知功能是否正常工作。\n\n发送时间: ' + formatBeijingTime();
          const description = '测试NotifyX通知功能';

          success = await sendNotifyXNotification(title, content, description, testConfig);
          消息=成功？ 'NotifyX通知发送成功' : 'NotifyX通知发送失败，请检查配置';
        } else if (body.type === 'webhook') {
          const testConfig = {
            ...配置，
            WEBHOOK_URL：body.WEBHOOK_URL，
            WEBHOOK_METHOD: body.WEBHOOK_METHOD,
            WEBHOOK_HEADERS: body.WEBHOOK_HEADERS,
            WEBHOOK_TEMPLATE: body.WEBHOOK_TEMPLATE
          };

          const title = '测试通知';
          const content = '这是一条测试通知，用于验证Webhook通知功能是否正常工作。\n\n发送时间: ' + formatBeijingTime();

          success = await sendWebhookNotification(title, content, testConfig);
          消息=成功？ 'Webhook通知发送成功' : 'Webhook通知发送失败，请检查配置';
         } else if (body.type === 'wechatbot') {
          const testConfig = {
            ...配置，
            微信_WEBHOOK：body.微信_WEBHOOK，
            WECHATBOT_MSG_TYPE: body.WECHATBOT_MSG_TYPE,
            移动端微信：body.移动端微信，
            微信全能：body.微信全能
          };

          const title = '测试通知';
          const content = '这是一条测试通知，用于验证企业微信机器人功能是否正常工作。\n\n发送时间: ' + formatBeijingTime();

          success = await sendWechatBotNotification(title, content, testConfig);
          消息=成功？ '企业微信机器人通知发送成功' : '企业微信机器人通知发送失败，请检查配置';
        } else if (body.type === 'email') {
          const testConfig = {
            ...配置，
            RESEND_API_KEY: body.RESEND_API_KEY,
            EMAIL_FROM: body.EMAIL_FROM,
            EMAIL_FROM_NAME: body.EMAIL_FROM_NAME,
            EMAIL_TO: body.EMAIL_TO
          };

          const title = '测试通知';
          const content = '这是一条测试通知，用于验证邮件通知功能是否正常工作。\n\n发送时间: ' + formatBeijingTime();

          success = await sendEmailNotification(title, content, testConfig);
          消息=成功？ '邮件通知发送成功' : '邮件通知发送失败，请检查配置';
        } else if (body.type === 'bark') {
          const testConfig = {
            ...配置，
            BARK_SERVER: body.BARK_SERVER,
            BARK_DEVICE_KEY: body.BARK_DEVICE_KEY,
            BARK_IS_ARCHIVE：body.BARK_IS_ARCHIVE
          };

          const title = '测试通知';
          const content = '这是一条测试通知，用于验证Bark通知功能是否正常工作。\n\n发送时间: ' + formatBeijingTime();

          success = await sendBarkNotification(title, content, testConfig);
          消息=成功？ 'Bark通知发送成功' : 'Bark通知发送失败，请检查';
        }

        返回新的响应(
          JSON.stringify({ success, message }),
          { headers: { 'Content-Type': 'application/json' } }
        ）；
      } catch (error) {
        console.error('测试通知失败:', error);
        返回新的响应(
          JSON.stringify({ success: false, message: '测试通知失败:' + error.message }),
          { status: 500, headers: { 'Content-Type': 'application/json' } }
        ）；
      }
    }

    如果 (路径 === '/subscriptions') {
      如果 (方法 === 'GET') {
        const subscriptions = await getAllSubscriptions(env);
        返回新的响应(
          JSON.stringify(subscriptions),
          { headers: { 'Content-Type': 'application/json' } }
        ）；
      }

      如果 (方法 === 'POST') {
        const subscription = await request.json();
        const result = await createSubscription(subscription, env);

        返回新的响应(
          JSON.stringify(result),
          {
            状态：result.success ? 201 : 400，
            headers: { 'Content-Type': 'application/json' }
          }
        ）；
      }
    }

    如果 (路径以'/subscriptions/'开头) {
      const parts = path.split('/');
      const id = parts[2];

      如果 (parts[3] === 'toggle-status' && method === 'POST') {
        const body = await request.json();
        const result = await toggleSubscriptionStatus(id, body.isActive, env);

        返回新的响应(
          JSON.stringify(result),
          {
            状态：result.success ? 200 : 400，
            headers: { 'Content-Type': 'application/json' }
          }
        ）；
      }

      如果 (parts[3] === 'test-notify' && method === 'POST') {
        const result = await testSingleSubscriptionNotification(id, env);
        return new Response(JSON.stringify(result), { status: result.success ? 200 : 500, headers: { 'Content-Type': 'application/json' } });
      }

      如果 (方法 === 'GET') {
        const subscription = await getSubscription(id, env);

        返回新的响应(
          JSON.stringify(subscription),
          { headers: { 'Content-Type': 'application/json' } }
        ）；
      }

      如果 (方法 === 'PUT') {
        const subscription = await request.json();
        const result = await updateSubscription(id, subscription, env);

        返回新的响应(
          JSON.stringify(result),
          {
            状态：result.success ? 200 : 400，
            headers: { 'Content-Type': 'application/json' }
          }
        ）；
      }

      如果 (方法 === 'DELETE') {
        const result = await deleteSubscription(id, env);

        返回新的响应(
          JSON.stringify(result),
          {
            状态：result.success ? 200 : 400，
            headers: { 'Content-Type': 'application/json' }
          }
        ）；
      }
    }

    // 处理第三方通知API
    如果 (路径以'/notify/'开头) {
      const pathSegments = path.split('/');
      // 允许通过路径、授权头或查询参数清晰方式确定访问令牌
      const tokenFromPath = pathSegments[2] || '';
      const tokenFromHeader = (request.headers.get('Authorization') || '').replace(/^Bearer\s+/i, '').trim();
      const tokenFromQuery = url.searchParams.get('token') || '';
      const providedToken = tokenFromPath || tokenFromHeader || tokenFromQuery;
      const expectedToken = config.THIRD_PARTY_API_TOKEN || '';

      如果 (!expectedToken) {
        返回新的响应(
          JSON.stringify({ message: '第三方API已禁用，请在后台配置访问令牌后使用' }),
          { status: 403, headers: { 'Content-Type': 'application/json' } }
        ）；
      }

      如果 (!providedToken || providedToken !== expectedToken) {
        返回新的响应(
          JSON.stringify({ message: '访问未授权，令牌无效或退出' }),
          { status: 401, headers: { 'Content-Type': 'application/json' } }
        ）；
      }

      如果 (方法 === 'POST') {
        尝试 {
          const body = await request.json();
          const 标题 = body.title || '第三方通知'；
          const content = body.content || '';

          如果 (!content) {
            返回新的响应(
              JSON.stringify({ message: '缺少必填参数内容' }),
              { status: 400, headers: { 'Content-Type': 'application/json' } }
            ）；
          }

          const config = await getConfig(env);
          const bodyTagsRaw = Array.isArray(body.tags)
            ？body.tags
            : (typeof body.tags === 'string' ? body.tags.split(/[,，\s]+/) : []);
          const bodyTags = Array.isArray(bodyTagsRaw)
            bodyTagsRaw.filter(tag => typeof tag === 'string' && tag.trim().length > 0).map(tag => tag.trim())
            : [];

          // 使用多渠道发送通知
          等待 sendNotificationToAllChannels(标题, 内容, config, '[第三方API]', {
            元数据：{ tags: bodyTags }
          });

          返回新的响应(
            JSON.stringify({
              message: '发送成功',
              回复： {
                错误代码：0
                错误信息：'好的'
                msgid: 'MSGID' + Date.now()
              }
            }),
            { headers: { 'Content-Type': 'application/json' } }
          ）；
        } catch (error) {
          console.error('[第三方API]发送通知失败:', error);
          返回新的响应(
            JSON.stringify({
              message: '发送失败',
              回复： {
                错误代码：1
                错误信息：错误消息
              }
            }),
            { status: 500, headers: { 'Content-Type': 'application/json' } }
          ）；
        }
      }
    }

    返回新的响应(
      JSON.stringify({ success: false, message: '未找到请求的资源' }),
      { status: 404, headers: { 'Content-Type': 'application/json' } }
    ）；
  }
};

// 工具函数
function generateRandomSecret() {
  // 生成一个64字符的随机遥控器
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*';
  let result = '';
  for (let i = 0; i < 64; i++) {
    result += chars.charAt(Math.floor(Math.random() * chars.length));
  }
  返回结果；
}

异步函数 getConfig(env) {
  尝试 {
    如果 (!env.SUBSCRIPTIONS_KV) {
      console.error('[配置] KV存储未绑定');
      throw new Error('KV存储未绑定');
    }

    const data = await env.SUBSCRIPTIONS_KV.get('config');
    console.log('[配置]从KV读取配置:', data ? '成功' : '空配置');

    const config = data ? JSON.parse(data) : {};

    //保证JWT_SECRET的一致性
    let jwtSecret = config.JWT_SECRET;
    如果 (!jwtSecret || jwtSecret === 'your-secret-key') {
      jwtSecret = generateRandomSecret();
      console.log('[配置]生成新的JWT密钥');

      // 保存新的 JWT 密钥
      const updatedConfig = { ...config, JWT_SECRET: jwtSecret };
      await env.SUBSCRIPTIONS_KV.put('config', JSON.stringify(updatedConfig));
    }

    const finalConfig = {
      ADMIN_USERNAME: config.ADMIN_USERNAME || 'admin',
      ADMIN_PASSWORD: config.ADMIN_PASSWORD || 'password',
      JWT_SECRET：jwtSecret，
      TG_BOT_TOKEN: config.TG_BOT_TOKEN || '',
      TG_CHAT_ID: config.TG_CHAT_ID || '',
      NOTIFYX_API_KEY: config.NOTIFYX_API_KEY || '',
      WEBHOOK_URL：config.WEBHOOK_URL || '',
      WEBHOOK_METHOD: config.WEBHOOK_METHOD || 'POST',
      WEBHOOK_HEADERS: config.WEBHOOK_HEADERS || '',
      WEBHOOK_TEMPLATE: config.WEBHOOK_TEMPLATE || '',
      SHOW_LUNAR：config.SHOW_LUNAR === true，
      WECHATBOT_WEBHOOK: config.WECHATBOT_WEBHOOK || '',
      WECHATBOT_MSG_TYPE: config.WECHATBOT_MSG_TYPE || 'text',
      WECHATBOT_AT_MOBILES: config.WECHATBOT_AT_MOBILES || '',
      WECHATBOT_AT_ALL: config.WECHATBOT_AT_ALL || 'false',
      RESEND_API_KEY: config.RESEND_API_KEY || '',
      EMAIL_FROM: config.EMAIL_FROM || '',
      EMAIL_FROM_NAME: config.EMAIL_FROM_NAME || '',
      EMAIL_TO: config.EMAIL_TO || '',
      BARK_DEVICE_KEY: config.BARK_DEVICE_KEY || '',
      BARK_SERVER: config.BARK_SERVER || 'https://api.day.app',
      BARK_IS_ARCHIVE: config.BARK_IS_ARCHIVE || 'false',
      ENABLED_NOTIFIERS: config.ENABLED_NOTIFIERS || ['notifyx'],
      时区：config.TIMEZONE || 'UTC', // 新增时区字段
      NOTIFICATION_HOURS: Array.isArray(config.NOTIFICATION_HOURS) ? config.NOTIFICATION_HOURS : [],
      第三方 API 令牌：config.THIRD_PARTY_API_TOKEN || ''
    };

    console.log('[配置]最终配置用户名:', FinalConfig.ADMIN_USERNAME);
    返回 finalConfig；
  } catch (error) {
    console.error('[配置]获取配置失败:', error);
    const defaultJwtSecret = generateRandomSecret();

    返回 {
      ADMIN_USERNAME: 'admin',
      ADMIN_PASSWORD: 'password',
      JWT_SECRET：defaultJwtSecret，
      TG_BOT_TOKEN: '',
      TG_CHAT_ID: '',
      NOTIFYX_API_KEY: '',
      WEBHOOK_URL: '',
      WEBHOOK_METHOD: 'POST',
      WEBHOOK_HEADERS: '',
      WEBHOOK_TEMPLATE: '',
      SHOW_LUNAR: true,
      WECHATBOT_WEBHOOK:'',
      WECHATBOT_MSG_TYPE: 'text',
      手机上的WECHATBOT：''，
      WECHATBOT_AT_ALL: 'false',
      RESEND_API_KEY: '',
      EMAIL_FROM: '',
      EMAIL_FROM_NAME: '',
      EMAIL_TO: '',
      ENABLED_NOTIFIERS: ['notifyx'],
      通知时间：[]
      TIMEZONE: 'UTC', // 新增时区字段
      第三方 API 令牌：''
    };
  }
}

异步函数 generateJWT(username, secret) {
  const header = { alg: 'HS256', typ: 'JWT' };
  const payload = { username, iat: Math.floor(Date.now() / 1000) };

  const headerBase64 = btoa(JSON.stringify(header));
  const payloadBase64 = btoa(JSON.stringify(payload));

  const signatureInput = headerBase64 + '.' + payloadBase64;
  const signature = await CryptoJS.HmacSHA256(signatureInput, secret);

  返回 headerBase64 + '.' + payloadBase64 + '.' + signature;
}

异步函数 verifyJWT(token, secret) {
  尝试 {
    如果 (!token || !secret) {
      console.log('[JWT] Token或Secret为空');
      返回空值；
    }

    const parts = token.split('.');
    如果（parts.length !== 3）{
      console.log('[JWT] Token格式错误，部分数量:', parts.length);
      返回空值；
    }

    const [headerBase64, payloadBase64, signature] = parts;
    const signatureInput = headerBase64 + '.' + payloadBase64;
    const expectedSignature = await CryptoJS.HmacSHA256(signatureInput, secret);

    如果 (签名 !== 预期签名) {
      console.log('[JWT]签名验证失败');
      返回空值；
    }

    const payload = JSON.parse(atob(payloadBase64));
    console.log('[JWT]验证成功，用户:', Payload.username);
    返回有效载荷；
  } catch (error) {
    console.error('[JWT]验证过程错误:', error);
    返回空值；
  }
}

异步函数 getAllSubscriptions(env) {
  尝试 {
    const data = await env.SUBSCRIPTIONS_KV.get('subscriptions');
    返回数据？JSON.parse(data) : [];
  } catch (error) {
    返回 [];
  }
}

async function getSubscription(id, env) {
  const subscriptions = await getAllSubscriptions(env);
  返回 subscriptions.find(s => s.id === id);
}

// 2.修改createSubscription，支持useLunar字段
async function createSubscription(subscription, env) {
  尝试 {
    const subscriptions = await getAllSubscriptions(env);

    如果 (!subscription.name || !subscription.expiryDate) {
      return { success: false, message: '缺货必填字段' };
    }

    let expiryDate = new Date(subscription.expiryDate);
    const config = await getConfig(env);
    const timezone = config?.TIMEZONE || 'UTC';
    const currentTime = getCurrentTimeInTimezone(timezone);
    

    let useLunar = !!subscription.useLunar;
    如果（使用月球）{
      let lunar = lunarCalendar.solar2lunar(
        expiryDate.getFullYear(),
        expiryDate.getMonth() + 1,
        expiryDate.getDate()
      ）；
      
      如果（月亮 && 订阅周期值 && 订阅周期单位）{
        // 如果预计日<=今天，自动推到算下一个周期
        while (expiryDate <= currentTime) {
          lunar = lunarBiz.addLunarPeriod(lunar, subscription.periodValue, subscription.periodUnit);
          const solar = lunarBiz.lunar2solar(lunar);
          expiryDate = new Date(solar.year, solar.month - 1, solar.day);
        }
        subscription.expiryDate = expiryDate.toISOString();
      }
    } 别的 {
      如果（到期日期 < 当前时间 && 订阅周期值 && 订阅周期单位）{
        while (expiryDate < currentTime) {
          如果 (subscription.periodUnit === 'day') {
            expiryDate.setDate(expiryDate.getDate() + subscription.periodValue);
          } else if (subscription.periodUnit === 'month') {
            expiryDate.setMonth(expiryDate.getMonth() + subscription.periodValue);
          } else if (subscription.periodUnit === 'year') {
            expiryDate.setFullYear(expiryDate.getFullYear() + subscription.periodValue);
          }
        }
        subscription.expiryDate = expiryDate.toISOString();
      }
    }

    const reminderSetting = resolveReminderSetting(subscription);

    const newSubscription = {
      id: Date.now().toString(), // 接口使用本地时钟
      名称：订阅名称，
      customType: subscription.customType || '',
      category: subscription.category ? subscription.category.trim() : '',
      开始日期：subscription.startDate || null，
      到期日期：subscription.到期日期，
      periodValue: subscription.periodValue || 1,
      periodUnit: subscription.periodUnit || 'month',
      提醒单元：remindSetting.unit，
      reminderValue: reminderSetting.value,
      reminderDays: reminderSetting.unit === 'day' ? reminderSetting.value : undefined,
      reminderHours: reminderSetting.unit === 'hour' ? reminderSetting.value : undefined,
      备注：订阅.备注 || '',
      isActive：subscription.isActive !== false，
      autoRenew: 订阅.autoRenew !== false,
      useLunar：useLunar，
      createdAt: new Date().toISOString()
    };

    subscriptions.push(newSubscription);

    await env.SUBSCRIPTIONS_KV.put('subscriptions', JSON.stringify(subscriptions));

    返回 { success: true, subscription: newSubscription };
  } catch (error) {
    console.error("创建订阅异常：", error && error.stack ? error.stack : error);
    返回 { 成功：错误，消息：错误 && error.message ？ error.message : '创建订阅失败' };
  }
}

// 3.修改updateSubscription，支持useLunar字段
async function updateSubscription(id, subscription, env) {
  尝试 {
    const subscriptions = await getAllSubscriptions(env);
    const index = subscriptions.findIndex(s => s.id === id);

    如果 (index === -1) {
      return { success: false, message: '订阅不存在' };
    }

    如果 (!subscription.name || !subscription.expiryDate) {
      return { success: false, message: '缺货必填字段' };
    }

    let expiryDate = new Date(subscription.expiryDate);
    const config = await getConfig(env);
    const timezone = config?.TIMEZONE || 'UTC';
    const currentTime = getCurrentTimeInTimezone(timezone);

let useLunar = !!subscription.useLunar;
如果（使用月球）{
  let lunar = lunarCalendar.solar2lunar(
    expiryDate.getFullYear(),
    expiryDate.getMonth() + 1,
    expiryDate.getDate()
  ）；
  如果（!lunar）{
    return { success: false, message: '农历日期超出支持范围（1900-2100年）' };
  }
  如果（月相 && 到期日 < 当前时间 && 订阅周期值 && 订阅周期单位）{
    // 新增：循环加周期，直到expiryDate > currentTime
    做 {
      lunar = lunarBiz.addLunarPeriod(lunar, subscription.periodValue, subscription.periodUnit);
      const solar = lunarBiz.lunar2solar(lunar);
      expiryDate = new Date(solar.year, solar.month - 1, solar.day);
    } while (expiryDate < currentTime);
    subscription.expiryDate = expiryDate.toISOString();
  }
} 别的 {
      如果（到期日期 < 当前时间 && 订阅周期值 && 订阅周期单位）{
        while (expiryDate < currentTime) {
          如果 (subscription.periodUnit === 'day') {
            expiryDate.setDate(expiryDate.getDate() + subscription.periodValue);
          } else if (subscription.periodUnit === 'month') {
            expiryDate.setMonth(expiryDate.getMonth() + subscription.periodValue);
          } else if (subscription.periodUnit === 'year') {
            expiryDate.setFullYear(expiryDate.getFullYear() + subscription.periodValue);
          }
        }
        subscription.expiryDate = expiryDate.toISOString();
      }
    }

    const reminderSource = {
      reminderUnit: subscription.reminderUnit !== undefined ? subscription.reminderUnit : subscriptions[index].reminderUnit,
      reminderValue: subscription.reminderValue !== undefined ? subscription.reminderValue : subscriptions[index].reminderValue,
      reminderHours: subscription.reminderHours !== undefined ? subscription.reminderHours : subscriptions[index].reminderHours,
      reminderDays: subscription.reminderDays !== undefined ? subscription.reminderDays : subscriptions[index].reminderDays
    };
    const reminderSetting = resolveReminderSetting(reminderSource);

    subscriptions[index] = {
      ...subscriptions[index]，
      名称：订阅名称，
      customType: subscription.customType || subscriptions[index].customType || '',
      category: subscription.category !== undefined ? subscription.category.trim() : (subscriptions[index].category || ''),
      开始日期：subscription.startDate || subscriptions[index].startDate，
      到期日期：subscription.到期日期，
      periodValue: subscription.periodValue || subscriptions[index].periodValue || 1,
      periodUnit: subscription.periodUnit || subscriptions[index].periodUnit || 'month',
      提醒单元：remindSetting.unit，
      reminderValue: reminderSetting.value,
      reminderDays: reminderSetting.unit === 'day' ? reminderSetting.value : undefined,
      reminderHours: reminderSetting.unit === 'hour' ? reminderSetting.value : undefined,
      备注：订阅.备注 || '',
      isActive: subscription.isActive !== undefined ? subscription.isActive : subscriptions[index].isActive,
      autoRenew: 订阅.autoRenew!== 未定义？ subscription.autoRenew : (subscriptions[index].autoRenew !== undefined ? subscriptions[index].autoRenew : true),
      useLunar：useLunar，
      updatedAt: new Date().toISOString()
    };

    await env.SUBSCRIPTIONS_KV.put('subscriptions', JSON.stringify(subscriptions));

    返回 { success: true, subscription: subscriptions[index] };
  } catch (error) {
    return { success: false, message: '更新订阅失败' };
  }
}

异步函数 deleteSubscription(id, env) {
  尝试 {
    const subscriptions = await getAllSubscriptions(env);
    const filteredSubscriptions = subscriptions.filter(s => s.id !== id);

    如果 (filteredSubscriptions.length === subscriptions.length) {
      return { success: false, message: '订阅不存在' };
    }

    await env.SUBSCRIPTIONS_KV.put('subscriptions', JSON.stringify(filteredSubscriptions));

    返回 { success: true };
  } catch (error) {
    return { success: false, message: '删除订阅失败' };
  }
}

async function toggleSubscriptionStatus(id, isActive, env) {
  尝试 {
    const subscriptions = await getAllSubscriptions(env);
    const index = subscriptions.findIndex(s => s.id === id);

    如果 (index === -1) {
      return { success: false, message: '订阅不存在' };
    }

    subscriptions[index] = {
      ...subscriptions[index]，
      isActive：isActive，
      updatedAt: new Date().toISOString()
    };

    await env.SUBSCRIPTIONS_KV.put('subscriptions', JSON.stringify(subscriptions));

    返回 { success: true, subscription: subscriptions[index] };
  } catch (error) {
    return { success: false, message: '更新订阅状态失败' };
  }
}

async function testSingleSubscriptionNotification(id, env) {
  尝试 {
    const subscription = await getSubscription(id, env);
    如果（!subscription）{
      return { success: false, message: '未找到该订阅' };
    }
    const config = await getConfig(env);

    const title = `手动测试通知：${subscription.name}`;

    // 检查是否显示农历（从配置中获取，默认不显示）
    const showLunar = config.SHOW_LUNAR === true;
    let lunarExpiryText = '';

    如果（显示月球）{
      // 计算农历日期
      const expiryDateObj = new Date(subscription.expiryDate);
      const lunarExpiry = lunarCalendar.solar2lunar(expiryDateObj.getFullYear(), expiryDateObj.getMonth() + 1, expiryDateObj.getDate());
      lunarExpiryText = lunarExpiry ? ` (农历: ${lunarExpiry.fullStr})` : '';
    }

    // 预测日期（使用所选时区）
    const timezone = config?.TIMEZONE || 'UTC';
    const formattedExpiryDate = formatTimeInTimezone(new Date(subscription.expiryDate), timezone, 'date');
    const currentTime = formatTimeInTimezone(new Date(), timezone, 'datetime');
    
    // 获取日历类型和自动续期状态
    const calendarType = subscription.useLunar ？ '农历' : '公历';
    const autoRenewText = 订阅.autoRenew ? '是' : '否';
    
    const commonContent = `**订阅详情**
类型：${subscription.customType || '其他'}
日历类型：${calendarType}
回复日期: ${formattedExpiryDate}${lunarExpiryText}
自动期续: ${autoRenewText}
备注: ${subscription.notes || '无'}
发送时间：${currentTime}
当前时区: ${formatTimezoneDisplay(timezone)}`;

    // 使用多渠道发送
    const tags = extractTagsFromSubscriptions([subscription]);
    wait sendNotificationToAllChannels(title, commonContent, config, '[手动测试]', {
      元数据：{标签}
    });

    return { success: true, message: '测试通知已发送到所有启用的渠道' };

  } catch (error) {
    console.error('[手动测试]发送失败:', error);
    return { success: false, message: '发送时发生错误:' + error.message };
  }
}

异步函数 sendWebhookNotification(title, content, config, metadata = {}) {
  尝试 {
    如果 (!config.WEBHOOK_URL) {
      console.error('[Webhook通知]通知未配置，缺少URL');
      返回 false；
    }

    console.log('[Webhook通知]开始发送通知到:' + config.WEBHOOK_URL);

    let requestBody;
    let headers = { 'Content-Type': 'application/json' };

    // 处理自定义请求头
    如果 (config.WEBHOOK_HEADERS) {
      尝试 {
        const customHeaders = JSON.parse(config.WEBHOOK_HEADERS);
        headers = { ...headers, ...customHeaders };
      } catch (error) {
        console.warn('[Webhook通知]自定义请求头格式错误，使用默认请求头');
      }
    }

    const tagsArray = Array.isArray(metadata.tags)
      ? metadata.tags.filter(tag => typeof tag === 'string' && tag.trim().length > 0).map(tag => tag.trim())
      : [];
    const tagsBlock = tagsArray.length ? tagsArray.map(tag => `- ${tag}`).join('\n') : '';
    const tagLine = tagArray.length ？ '标签：' + tagArray.join('、') : '';
    const timestamp = formatTimeInTimezone(new Date(), config?.TIMEZONE || 'UTC', 'datetime');
    const formattedMessage = [标题,内容,tagsLine,`发送时间：${timestamp}`]
      .filter(section => section && section.trim().length > 0)
      .join('\n\n');

    const templateData = {
      标题，
      内容，
      标签：tagsBlock，
      tagsLine，
      rawTags：tagsArray，
      时间戳
      格式化消息，
      消息：格式化消息
    };

    const escapeForJson = (value) => {
      如果 (value === null || value === undefined) {
        返回 '';
      }
      返回 JSON.stringify(String(value)).slice(1, -1);
    };

    const applyTemplate = (template, data) => {
      const templateString = JSON.stringify(template);
      const replaced = templateString.replace(/\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g, (_, key) => {
        if (Object.prototype.hasOwnProperty.call(data, key)) {
          返回 escapeForJson(data[key]);
        }
        返回 '';
      });
      返回 JSON.parse(替换后的内容);
    };

    // 处理消息模板
    如果 (config.WEBHOOK_TEMPLATE) {
      尝试 {
        const template = JSON.parse(config.WEBHOOK_TEMPLATE);
        requestBody = applyTemplate(template, templateData);
      } catch (error) {
        console.warn('[Webhook通知]消息模板格式错误，使用默认格式');
        请求体 = {
          标题，
          内容，
          tags: tagsArray,
          tagsLine，
          时间戳
          消息：格式化消息
        };
      }
    } 别的 {
      请求体 = {
        标题，
        内容，
        tags: tagsArray,
        tagsLine，
        时间戳
        消息：格式化消息
      };
    }

    const response = await fetch(config.WEBHOOK_URL, {
      方法：config.WEBHOOK_METHOD || 'POST'，
      标题：标题，
      body: JSON.stringify(requestBody)
    });

    const result = await response.text();
    console.log('[Webhook通知]发送结果:', response.status, result);
    返回 response.ok；
  } catch (error) {
    console.error('[Webhook通知]发送通知失败:', error);
    返回 false；
  }
}

异步函数 sendWeComNotification(message, config) {
    // 这是一个占位符。在实际应用中，您需要在此处实现 WeCom 通知逻辑。
    console.log("[企业微信]通知功能未实现");
    return { success: false, message: "企业微信通知功能未实现" };
}

异步函数 sendWechatBotNotification(title, content, config) {
  尝试 {
    如果 (!config.WECHATBOT_WEBHOOK) {
      console.error('[企业微信机器人]通知未配置，缺少Webhook URL');
      返回 false；
    }

    console.log('[企业微信机器人]开始发送通知到:' + config.WECHATBOT_WEBHOOK);

    // 构建消息内容
    let messageData;
    const msgType = config.WECHATBOT_MSG_TYPE || 'text';

    如果 (msgType === 'markdown') {
      // Markdown 消息格式
      const markdownContent = `# ${title}\n\n${content}`;
      messageData = {
        msgtype: 'markdown',
        markdown: {
          内容：markdown内容
        }
      };
    } 别的 {
      // 文本消息格式 - 优化显示
      const textContent = `${title}\n\n${content}`;
      messageData = {
        消息类型：'文本'，
        文本： {
          内容：文本内容
        }
      };
    }

    // 处理@功能
    如果 (config.WECHATBOT_AT_ALL === 'true') {
      //@所有者
      如果 (msgType === 'text') {
        messageData.text.mentioned_list = ['@all'];
      }
    } else if (config.WECHATBOT_AT_MOBILES) {
      // @指定手机号
      const mobiles = config.WECHATBOT_AT_MOBILES.split(',').map(m => m.trim()).filter(m => m);
      如果 (mobiles.length > 0) {
        如果 (msgType === 'text') {
          messageData.text.mentioned_mobile_list = 手机;
        }
      }
    }

    console.log('[企业微信机器人]发送消息数据:', JSON.stringify(messageData, null, 2));

    const response = await fetch(config.WECHATBOT_WEBHOOK, {
      方法：'POST'，
      标题：{
        'Content-Type': 'application/json'
      },
      正文：JSON.stringify(messageData)
    });

    const responseText = await response.text();
    console.log('[企业微信机器人]响应状态:', response.status);
    console.log('[企业微信机器人]响应内容:',responseText);

    如果 (response.ok) {
      尝试 {
        const result = JSON.parse(responseText);
        如果 (result.errcode === 0) {
          console.log('[企业微信机器人]通知发送成功');
          返回 true；
        } 别的 {
          console.error('[企业微信机器人]发送失败，错误码:', result.errcode, '错误信息:', result.errmsg);
          返回 false；
        }
      } catch (parseError) {
        console.error('[企业微信机器人]解析响应失败:', parseError);
        返回 false；
      }
    } 别的 {
      console.error('[企业微信机器人] HTTP请求失败，状态码:', response.status);
      返回 false；
    }
  } catch (error) {
    console.error('[企业微信机器人]发送通知失败:', error);
    返回 false；
  }
}

// 优化通知内容格式
function resolveReminderSetting(subscription) {
  const defaultDays = subscription && subscription.reminderDays !== undefined ? Number(subscription.reminderDays) : 7;
  let unit = subscription && subscription.reminderUnit === 'hour' ? 'hour' : 'day';

  令值；
  如果（单位 === 'hour'）{
    如果（subscription 存在 && subscription.reminderValue !== undefined && subscription.reminderValue !== null && !isNaN(Number(subscription.reminderValue))) {
      value = Number(subscription.reminderValue);
    } else if (subscription && subscription.reminderHours !== undefined && subscription.reminderHours !== null && !isNaN(Number(subscription.reminderHours))) {
      value = Number(subscription.reminderHours);
    } 别的 {
      值 = 0；
    }
  } 别的 {
    如果（subscription 存在 && subscription.reminderValue !== undefined && subscription.reminderValue !== null && !isNaN(Number(subscription.reminderValue))) {
      value = Number(subscription.reminderValue);
    } else if (!isNaN(defaultDays)) {
      value = Number(defaultDays);
    } 别的 {
      值 = 7；
    }
  }

  如果 (value < 0 || isNaN(value)) {
    值 = 0；
  }

  返回 { 单位，值 }；
}

function shouldTriggerReminder(reminder, daysDiff, hoursDiff) {
  如果（!reminder）{
    返回 false；
  }
  如果 (提醒.单位 === 'hour') {
    如果 (reminder.value === 0) {
      返回 hoursDiff >= 0 && hoursDiff < 1；
    }
    返回 hoursDiff >= 0 && hoursDiff <= reminder.value;
  }
  如果 (reminder.value === 0) {
    返回 daysDiff === 0；
  }
  返回 daysDiff >= 0 && daysDiff <= reminder.value;
}

function formatNotificationContent(subscriptions, config) {
  const showLunar = config.SHOW_LUNAR === true;
  const timezone = config?.TIMEZONE || 'UTC';
  let content = '';

  for (const sub of subscriptions) {
    const typeText = sub.customType || '其他'；
    const periodText = (sub.periodValue && sub.periodUnit) ? `(周期: ${sub.periodValue} ${ { day: '天', month: '月', year: '年' }[sub.periodUnit] || sub.periodUnit})` : '';
    const 类别文本 = 子类别 ? sub.category : '未分类';
    const reminderSetting = resolveReminderSetting(sub);

    // 预测日期（使用所选时区）
    const expiryDateObj = new Date(sub.expiryDate);
    const formattedExpiryDate = formatTimeInTimezone(expiryDateObj, timezone, 'date');
    
    // 农历日期
    let lunarExpiryText = '';
    如果（显示月球）{
      const lunarExpiry = lunarCalendar.solar2lunar(expiryDateObj.getFullYear(), expiryDateObj.getMonth() + 1, expiryDateObj.getDate());
      lunarExpiryText = lunarExpiry ? `
农历日期：${lunarExpiry.fullStr}`：''；
    }

    // 状态和预计时间
    let statusText = '';
    let statusEmoji = '';
    如果 (sub.daysRemaining === 0) {
      statusEmoji = '⚠️';
      statusText = '今天到达！';
    } else if (sub.daysRemaining < 0) {
      statusEmoji = '🚨';
      statusText = `已过渡 ${Math.abs(sub.daysRemaining)} 天`;
    } 别的 {
      statusEmoji = '📅';
      statusText = `将在 ${sub.daysRemaining} 天后兑`;
    }

    const reminderSuffix = reminderSetting.value === 0
      ？ '（仅提示时提醒）'
      : (reminderSetting.unit === '小时' ? '（小时级提醒）' : '');
    const reminderText = reminderSetting.unit === 'hour'
      ？ `提醒策略：提前${reminderSetting.value}小时${reminderSuffix}`
      : `提醒策略：提前${reminderSetting.value}天${reminderSuffix}`;

    // 获取日历类型和自动续期状态
    const calendarType = sub.useLunar ？ '农历' : '公历';
    常量 autoRenewText = sub.autoRenew ? '是' : '否';
    
    // 构建格式化的通知内容
    const subscriptionContent = `${statusEmoji} **${sub.name}**
类型：${typeText} ${periodText}
分类: ${categoryText}
日历类型：${calendarType}
回复日期: ${formattedExpiryDate}${lunarExpiryText}
自动期续: ${autoRenewText}
${reminderText}
回复状态: ${statusText}`;

    //添加备注
    let finalContent = sub.notes ?
      订阅内容 + `\n 备注: ${sub.notes}` :
      订阅内容；

    content += finalContent + '\n\n';
  }

  //添加发送时间和时区信息
  const currentTime = formatTimeInTimezone(new Date(), timezone, 'datetime');
  content += `发送时间: ${currentTime}\n当前时区: ${formatTimezoneDisplay(timezone)}`;

  返回内容；
}

异步函数 sendNotificationToAllChannels(title, commonContent, config, logPrefix = '[定时任务]', options = {}) {
  const metadata = options.metadata || {};
    如果 (!config.ENABLED_NOTIFIERS || config.ENABLED_NOTIFIERS.length === 0) {
        console.log(`${logPrefix} 未启用任何通知渠道。`);
        返回;
    }

    如果 (config.ENABLED_NOTIFIERS.includes('notifyx')) {
        const notifyxContent = `## ${title}\n\n${commonContent}`;
        const success =等待sendNotifyXNotification（标题，notifyxContent，`订阅提醒`，config）;
        console.log(`${logPrefix} 发送NotifyX通知 ${success ? '成功' : '失败'}`);
    }
    如果 (config.ENABLED_NOTIFIERS.includes('telegram')) {
        const telegramContent = `*${title}*\n\n${commonContent}`;
        const success = await sendTelegramNotification(telegramContent, config);
        console.log(`${logPrefix} 发送Telegram通知 ${success ? '成功' : '失败'}`);
    }
    如果 (config.ENABLED_NOTIFIERS.includes('webhook')) {
        const webhookContent = commonContent.replace(/(\**|\*|##|#|`)/g, '');
        const success = await sendWebhookNotification(title, webhookContent, config, metadata);
        console.log(`${logPrefix} 发送Webhook通知 ${success ? '成功' : '失败'}`);
    }
    if (config.ENABLED_NOTIFIERS.includes('wechatbot')) {
        const wechatbotContent = commonContent.replace(/(\**|\*|##|#|`)/g, '');
        const success = await sendWechatBotNotification(title, wechatbotContent, config);
        console.log(`${logPrefix} 发送企业微信机器人通知 ${success ? '成功' : '失败'}`);
    }
    如果 (config.ENABLED_NOTIFIERS.includes('weixin')) {
        const weixinContent = `【${title}】\n\n${commonContent.replace(/(\**|\*|##|#|`)/g, '')}`;
        const result = await sendWeComNotification(weixinContent, config);
        console.log(`${logPrefix} 发送企业微信通知${result.success ? '成功' : '失败'}.${result.message}`);
    }
    如果 (config.ENABLED_NOTIFIERS.includes('email')) {
        const emailContent = commonContent.replace(/(\**|\*|##|#|`)/g, '');
        const success = await sendEmailNotification(title, emailContent, config);
        console.log(`${logPrefix} 发送邮件通知 ${success ? '成功' : '失败'}`);
    }
    如果 (config.ENABLED_NOTIFIERS.includes('bark')) {
        const barkContent = commonContent.replace(/(\**|\*|##|#|`)/g, '');
        const success = await sendBarkNotification(title, barkContent, config);
        console.log(`${logPrefix} 发送Bark通知 ${success ? '成功' : '失败'}`);
    }
}

异步函数 sendTelegramNotification(message, config) {
  尝试 {
    如果 (!config.TG_BOT_TOKEN || !config.TG_CHAT_ID) {
      console.error('[Telegram]通知未配置，缺少Bot Token或聊天ID');
      返回 false；
    }

    console.log('[Telegram] 开始发送通知到聊天 ID: ' + config.TG_CHAT_ID);

    const url = 'https://api.telegram.org/bot' + config.TG_BOT_TOKEN + '/sendMessage';
    const response = await fetch(url, {
      方法：'POST'，
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        chat_id: config.TG_CHAT_ID,
        短信，
        解析模式：'Markdown'
      })
    });

    const result = await response.json();
    console.log('[Telegram] 发送结果:', result);
    返回 result.ok；
  } catch (error) {
    console.error('[Telegram]发送通知失败:', error);
    返回 false；
  }
}

异步函数 sendNotifyXNotification(title, content, description, config) {
  尝试 {
    如果 (!config.NOTIFYX_API_KEY) {
      console.error('[NotifyX]通知未配置，缺少API Key');
      返回 false；
    }

    console.log('[NotifyX] 开始发送通知: ' + title);

    const url = 'https://www.notifyx.cn/api/v1/send/' + config.NOTIFYX_API_KEY;
    const response = await fetch(url, {
      方法：'POST'，
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        标题：标题，
        内容：内容，
        描述：描述 || ''
      })
    });

    const result = await response.json();
    console.log('[NotifyX] 发送结果:', result);
    返回结果状态 === '已排队'；
  } catch (error) {
    console.error('[NotifyX]发送通知失败:', error);
    返回 false；
  }
}

异步函数 sendBarkNotification(title, content, config) {
  尝试 {
    如果 (!config.BARK_DEVICE_KEY) {
      console.error('[Bark] 通知未配置，缺少设备Key');
      返回 false；
    }

    console.log('[Bark] 开始发送通知到设备: ' + config.BARK_DEVICE_KEY);

    const serverUrl = config.BARK_SERVER || 'https://api.day.app';
    const url = serverUrl + '/push';
    const payload = {
      标题：标题，
      正文：内容，
      设备密钥：config.BARK_DEVICE_KEY
    };

    // 如果配置了保存参数，则添加isArchive参数
    如果 (config.BARK_IS_ARCHIVE === 'true') {
      payload.isArchive = 1;
    }

    const response = await fetch(url, {
      方法：'POST'，
      标题：{
        'Content-Type': 'application/json; charset=utf-8'
      },
      body: JSON.stringify(payload)
    });

    const result = await response.json();
    console.log('[Bark] 发送结果:', result);
    
    // Bark API返回code为200表示成功
    返回 result.code === 200；
  } catch (error) {
    console.error('[Bark]发送通知失败:', error);
    返回 false；
  }
}

异步函数 sendEmailNotification(title, content, config) {
  尝试 {
    如果 (!config.RESEND_API_KEY || !config.EMAIL_FROM || !config.EMAIL_TO) {
      console.error('[邮件通知]通知未配置，缺少必要参数');
      返回 false；
    }

    console.log('[邮件通知]开始发送邮件到:' + config.EMAIL_TO);

    // 生成HTML邮件内容
    const htmlContent = `
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>${title}</title>
    <style>
        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 0; padding: 0; background-color: #f5f5f5; }
        .container { max-width: 600px; margin: 0 auto; background-color: #ffffff; }
        .header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 30px 20px; text-align: center; }
        .header h1 { color: white; margin: 0; font-size: 24px; }
        .content { padding: 30px 20px; }
        .content h2 { color: #333; margin-top: 0; }
        .content p { color: #666; line-height: 1.6; margin: 16px 0; }
        .footer { background-color: #f8f9fa; padding: 20px; text-align: center; color: #666; font-size: 14px; }
        .highlight { background-color: #e3f2fd; padding: 15px; border-radius: 8px; margin: 20px 0; }
        .button { display: inline-block; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 12px 24px; text-decoration: none; border-radius: 6px; margin: 20px 0; }
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>📅 ${title}</h1>
        </div>
        <div class="content">
            <div class="highlight">
                ${content.replace(/\n/g, '<br>')}
            </div>
            <p>此邮件由订阅管理系统自动发送，请及时处理相关订阅事务。</p>
        </div>
        <div class="footer">
            <p>订阅管理系统| 发送时间: ${formatTimeInTimezone(new Date(), config?.TIMEZONE || 'UTC', 'datetime')}</p>
        </div>
    </div>
</body>
</html>`;

    const fromEmail = config.EMAIL_FROM_NAME ?
      `${config.EMAIL_FROM_NAME} <${config.EMAIL_FROM}>` :
      config.EMAIL_FROM;

    const response = await fetch('https://api.resend.com/emails', {
      方法：'POST'，
      标题：{
        '授权': `Bearer ${config.RESEND_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        发件人：fromEmail，
        至：config.EMAIL_TO，
        主题：标题，
        html：html内容，
        text: content // 纯文本备用
      })
    });

    const result = await response.json();
    console.log('[邮件通知]发送结果:', response.status, result);

    如果 (response.ok && result.id) {
      console.log('[邮件通知]邮件发送成功，ID:', result.id);
      返回 true；
    } 别的 {
      console.error('[邮件通知]邮件发送失败:', result);
      返回 false；
    }
  } catch (error) {
    console.error('[邮件通知]发送邮件失败:', error);
    返回 false；
  }
}

异步函数 sendNotification(title, content, description, config) {
  如果 (config.NOTIFICATION_TYPE === 'notifyx') {
    return await sendNotifyXNotification(title, content, description, config);
  } 别的 {
    return await sendTelegramNotification(content, config);
  }
}

// 4.修改定时任务checkExpiringSubscriptions，支持农历周期自动续订和农历提醒
异步函数 checkExpiringSubscriptions(env) {
  尝试 {
    const config = await getConfig(env);
    const timezone = config?.TIMEZONE || 'UTC';
    const currentTime = getCurrentTimeInTimezone(timezone);
    console.log('[定时任务]开始检查即将订阅的UTC: ' + new Date().toISOString() + ', ' + timezone + ': ' + currentTime.toLocaleString('zh-CN', {timeZone: timezone}));

    const currentMidnight = getTimezoneMidnightTimestamp(currentTime, 时区); // 统一计算当天的零点时间，避免多次修复

    const rawNotificationHours = Array.isArray(config.NOTIFICATION_HOURS) ? config.NOTIFICATION_HOURS : [];
    const normalizedNotificationHours = rawNotificationHours
      .map(value => String(value).trim())
      .filter(value => value.length > 0)
      .map(value => value === '*' ? '*' : value.toUpperCase() === 'ALL' ? 'ALL' : value.padStart(2, '0'));
    const allowAllHours = normalizedNotificationHours.includes('*') || normalizedNotificationHours.includes('ALL');
    const hourFormatter = new Intl.DateTimeFormat('en-US', { timeZone: timezone, hour12: false, hour: '2-digit' });
    const currentHour = hourFormatter.format(currentTime);
    const shouldNotifyThisHour = allowAllHours || normalizedNotificationHours.length === 0 || normalizedNotificationHours.includes(currentHour);

    const subscriptions = await getAllSubscriptions(env);
    console.log('[定时任务]共找到' + subscriptions.length + '个订阅');
    const expiringSubscriptions = [];
    const updatedSubscriptions = [];
    let hasUpdates = false;

for (const subscription of subscriptions) {
  如果（subscription.isActive === false）{
    console.log('[定时任务]订阅 "' + subscription.name + '" 已终止，跳过');
    继续;
  }

  const reminderSetting = resolveReminderSetting(subscription);
  令 diffMs = 0；
  let diffHours = 0;
  let daysDiff;
  如果 (subscription.useLunar) {
    const expiryDate = new Date(subscription.expiryDate);
    let lunar = lunarCalendar.solar2lunar(
      expiryDate.getFullYear(),
      expiryDate.getMonth() + 1,
      expiryDate.getDate()
    ）；
    const solar = lunarBiz.lunar2solar(lunar);
    const lunarDate = new Date(solar.year, solar.month - 1, solar.day);
    const lunarMidnight = getTimezoneMidnightTimestamp(lunarDate, timezone);
    
    daysDiff = Math.round((lunarMidnight - currentMidnight) / MS_PER_DAY);

    console.log('[定时任务]订阅 "' + subscription.name + '" 回复日期: ' + expiryDate.toISOString() + ', 农历转换后午夜时间: ' + new Date(lunarMidnight).toISOString() + ', 剩余天数: ' + daysDiff);

    diffMs = expiryDate.getTime() - currentTime.getTime();
    diffHours = diffMs / MS_PER_HOUR;

    如果（天数差 < 0 && 订阅周期值 && 订阅周期单位 && 订阅自动续订 !== false）{
      let nextLunar = lunar;
      做 {
        nextLunar = lunarBiz.addLunarPeriod(nextLunar, subscription.periodValue, subscription.periodUnit);
        const solar = lunarBiz.lunar2solar(nextLunar);
        var newExpiryDate = new Date(solar.year, solar.month - 1, solar.day);
        const newLunarMidnight = getTimezoneMidnightTimestamp(newExpiryDate, timezone);
        daysDiff = Math.round((newLunarMidnight - currentMidnight) / MS_PER_DAY);
        console.log('[定时任务]订阅 "' + subscription.name + '" 更新日期: ' + newExpiryDate.toISOString() + ', 农历转换后午夜时间: ' + new Date(newLunarMidnight).toISOString() + ', 剩余天数: ' + daysDiff);
      } while (daysDiff < 0);

      diffMs = newExpiryDate.getTime() - currentTime.getTime();
      diffHours = diffMs / MS_PER_HOUR;

      const updatedSubscription = { ...subscription, expiryDate: newExpiryDate.toISOString() };
      updatedSubscriptions.push(updatedSubscription);
      hasUpdates = true;

      const shouldRemindAfterRenewal = shouldTriggerReminder(reminderSetting, daysDiff, diffHours);
      如果（应该在续订后提醒）{
        console.log('[定时任务]订阅 "' + subscription.name + '" 提醒在范围内，将发送通知');
        expiringSubscriptions.push({
          ...更新订阅，
          剩余天数：天差，
          剩余小时数：Math.round(diffHours)
        });
      }
      继续;
    }
  } 别的 {
    const expiryDate = new Date(subscription.expiryDate);
    const expiryMidnight = getTimezoneMidnightTimestamp(expiryDate, timezone);

    daysDiff = Math.round((expiryMidnight - currentMidnight) / MS_PER_DAY);

    console.log('[定时任务]订阅 "' + subscription.name + '" 回复日期: ' + expiryDate.toISOString() + ', 时区午夜时间: ' + new Date(expiryMidnight).toISOString() + ', 剩余天数: ' + daysDiff);

    diffMs = expiryDate.getTime() - currentTime.getTime();
    diffHours = diffMs / MS_PER_HOUR;

    如果（天数差 < 0 && 订阅周期值 && 订阅周期单位 && 订阅自动续订 !== false）{
      const newExpiryDate = new Date(expiryDate);

      如果 (subscription.periodUnit === 'day') {
        newExpiryDate.setDate(expiryDate.getDate() + subscription.periodValue);
      } else if (subscription.periodUnit === 'month') {
        newExpiryDate.setMonth(expiryDate.getMonth() + subscription.periodValue);
      } else if (subscription.periodUnit === 'year') {
        newExpiryDate.setFullYear(expiryDate.getFullYear() + subscription.periodValue);
      }

      let newExpiryMidnight = getTimezoneMidnightTimestamp(newExpiryDate, timezone);
      while (newExpiryMidnight < currentMidnight) {
        console.log('[定时任务]新计算的转换日期 ' + newExpiryDate.toISOString() + ' (时区转换后午夜: ' + new Date(newExpiryMidnight).toISOString() + ') 仍然，过渡继续计算下一个周期');
        如果 (subscription.periodUnit === 'day') {
          newExpiryDate.setDate(newExpiryDate.getDate() + subscription.periodValue);
        } else if (subscription.periodUnit === 'month') {
          newExpiryDate.setMonth(newExpiryDate.getMonth() + subscription.periodValue);
        } else if (subscription.periodUnit === 'year') {
          newExpiryDate.setFullYear(newExpiryDate.getFullYear() + subscription.periodValue);
        }
        newExpiryMidnight = getTimezoneMidnightTimestamp(newExpiryDate, timezone);
      }

      console.log('[定时任务]订阅 "' + subscription.name + '" 更新近期日期: ' + newExpiryDate.toISOString());

      diffMs = newExpiryDate.getTime() - currentTime.getTime();
      diffHours = diffMs / MS_PER_HOUR;

      const updatedSubscription = { ...subscription, expiryDate: newExpiryDate.toISOString() };
      updatedSubscriptions.push(updatedSubscription);
      hasUpdates = true;

      const newDaysDiff = Math.round((newExpiryMidnight - currentMidnight) / MS_PER_DAY);
      const shouldRemindAfterRenewal = shouldTriggerReminder(reminderSetting, newDaysDiff, diffHours);
      如果（应该在续订后提醒）{
        console.log('[定时任务]订阅 "' + subscription.name + '" 提醒在范围内，将发送通知');
        expiringSubscriptions.push({
          ...更新订阅，
          剩余天数：新天数差，
          剩余小时数：Math.round(diffHours)
        });
      }
      继续;
    }
  }

  diffMs = new Date(subscription.expiryDate).getTime() - currentTime.getTime();
  diffHours = diffMs / MS_PER_HOUR;
  const shouldRemind = shouldTriggerReminder(reminderSetting, daysDiff, diffHours);

  if (daysDiff < 0 && subscription.autoRenew === false) {
    console.log('[定时任务]订阅 "' + subscription.name + '" 已过期且未启用自动续订，将发送过期通知');
    expiringSubscriptions.push({
      ...订阅，
      剩余天数：天差，
      剩余小时数：Math.round(diffHours)
    });
  } else if (shouldRemind) {
    console.log('[定时任务]订阅 "' + subscription.name + '" 提醒在范围内，将发送通知');
    expiringSubscriptions.push({
      ...订阅，
      剩余天数：天差，
      剩余小时数：Math.round(diffHours)
    });
  }
}

    如果（有更新）{
      const mergedSubscriptions = subscriptions.map(sub => {
        const updated = updatedSubscriptions.find(u => u.id === sub.id);
        返回更新后的子程序；
      });
      await env.SUBSCRIPTIONS_KV.put('subscriptions', JSON.stringify(mergedSubscriptions));
    }

    如果（过期订阅.长度 > 0）{
      如果 (!shouldNotifyThisHour) {
        console.log('[定时任务]当前小时' + currentHour + '未配置为自治时间，跳过发送通知');
        expiringSubscriptions.length = 0;
      } 别的 {
        // 按一下时间排序
        expiringSubscriptions.sort((a, b) => a.daysRemaining - b.daysRemaining);

        // 使用优化的格式化函数
        const commonContent = formatNotificationContent(expiringSubscriptions, config);
        const metadataTags = extractTagsFromSubscriptions(expiringSubscriptions);

        const title = '订阅提醒';
        wait sendNotificationToAllChannels(title, commonContent, config, '[定时任务]', {
          元数据：{ 标签：metadataTags }
        });
      }
    }
  } catch (error) {
    console.error('[定时任务]检查即将到来的订阅失败:', error);
  }
}

function getCookieValue(cookieString, key) {
  如果 (!cookieString) 返回 null；

  const match = cookieString.match(new RegExp('(^| )' + key + '=([^;]+)'));
  返回匹配项？匹配项[2]：null；
}

异步函数 handleRequest(request, env, ctx) {
  返回新的 Response(loginPage, {
    headers: { 'Content-Type': 'text/html; charset=utf-8' }
  });
}

const CryptoJS = {
  HmacSHA256: 函数(message, key) {
    const keyData = new TextEncoder().encode(key);
    const messageData = new TextEncoder().encode(message);

    return Promise.resolve().then(() => {
      返回 crypto.subtle.importKey(
        “生的”，
        keyData，
        { name: "HMAC", hash: {name: "SHA-256"}},
        错误的，
        [“符号”]
      ）；
    }).then(cryptoKey => {
      返回 crypto.subtle.sign(
        “HMAC”，
        加密密钥，
        消息数据
      ）；
    }).then(buffer => {
      const hashArray = Array.from(new Uint8Array(buffer));
      return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
    });
  }
};

function getCurrentTime(config) {
  const timezone = config?.TIMEZONE || 'UTC';
  const currentTime = getCurrentTimeInTimezone(timezone);
  const formatter = new Intl.DateTimeFormat('zh-CN', {
    时区：时区，
    年份：'数字'，月份：'两位数'，日期：'两位数'，
    小时：两位数，分钟：两位数，秒：两位数
  });
  返回 {
    日期：当前时间，
    localString: formatter.format(currentTime),
    isoString: currentTime.toISOString()
  };
}

export default {
  异步获取(请求，环境，ctx) {
    const url = new URL(request.url);

    //添加调试页面
    如果 (url.pathname === '/debug') {
      尝试 {
        const config = await getConfig(env);
        const debugInfo = {
          timestamp: new Date().toISOString(), // 使用UTC时钟
          路径名：url.路径名，
          kvBinding: !!env.SUBSCRIPTIONS_KV,
          configExists: !!config,
          adminUsername: config.ADMIN_USERNAME,
          hasJwtSecret: !!config.JWT_SECRET,
          jwtSecretLength: config.JWT_SECRET ? config.JWT_SECRET.length : 0
        };

        返回新的响应(`
<!DOCTYPE html>
<html>
<head>
  <title>调试信息</title>
  <style>
    body { font-family: monospace; padding: 20px; background: #f5f5f5; }
    .info { background: white; padding: 15px; margin: 10px 0; border-radius: 5px; }
    .success { 颜色：绿色； }
    .error { color: red; }
  </style>
</head>
<body>
  <h1>系统调试信息</h1>
  <div class="info">
    <h3>基本信息</h3>
    <p>时间：${debugInfo.timestamp}</p>
    <p>路径：${debugInfo.pathname}</p>
    <p class="${debugInfo.kvBinding ? 'success' : 'error'}">键绑定：${debugInfo.kvBinding ? '✓' : '✗'}</p>
  </div>

  <div class="info">
    <h3>配置信息</h3>
    <p class="${debugInfo.configExists ? 'success' : 'error'}">配置存在: ${debugInfo.configExists ? '✓' : '✗'}</p>
    <p>管理员用户名：${debugInfo.adminUsername}</p>
    <p class="${debugInfo.hasJwtSecret ? 'success' : 'error'}">JWT 密钥：${debugInfo.hasJwtSecret ? '✓' : '✗'}（长度：${debugInfo.jwtSecretLength}）</p>
  </div>

  <div class="info">
    <h3>解决方案</h3>
    <p>1. 确定KV命名空间已正确绑定为SUBSCRIPTIONS_KV</p>
    <p>2. 尝试访问 <a href="/">/</a> 进行登录</p>
    <p>3. 如果问题，请检查Cloudflare Workers日志</p>
  </div>
</body>
</html>`, {
          headers: { 'Content-Type': 'text/html; charset=utf-8' }
        });
      } catch (error) {
        返回新的响应（`调试页面错误：$ {error.message}`，{
          状态：500
          headers: { 'Content-Type': 'text/plain; charset=utf-8' }
        });
      }
    }

    如果 (url.pathname.startsWith('/api')) {
      return api.handleRequest(request, env, ctx);
    } else if (url.pathname.startsWith('/admin')) {
      return admin.handleRequest(request, env, ctx);
    } 别的 {
      返回 handleRequest(request, env, ctx);
    }
  },

  async scheduled(event, env, ctx) {
    const config = await getConfig(env);
    const timezone = config?.TIMEZONE || 'UTC';
    const currentTime = getCurrentTimeInTimezone(timezone);
    console.log('[Workers]定时任务触发UTC:', new Date().toISOString(), timezone + ':', currentTime.toLocaleString('zh-CN', {timeZone: timezone}));
    await checkExpiringSubscriptions(env);
  }
};