import { getPendingSyncRecords, getPendingSyncRecordCount, markRecordSynced, cleanOldRecords, getOfflineConfig, saveOfflineConfig } from './db';
import { deleteLocalImage } from './fs';
import { uploadImage } from '../api/upload';
import { addVisitorRecord, idCardSingOut, pullSigninData, pullSignoutData } from '../api/visitorRecord';
import { getVisitAreaTree } from '../api/visitArea';

let isSyncing = false;

const getCurrentNetworkType = async () => {
  return new Promise(resolve => {
    uni.getNetworkType({
      success: (res) => resolve(res.networkType),
      fail: () => resolve('unknown')
    });
  });
};

/**
 * 启动离线数据同步队列
 * 核心逻辑：
 * 1. 查询所有未同步的数据
 * 2. 如果有图片路径，先上传图片获取云端 URL
 * 3. 提交完整业务数据到后端
 * 4. 成功后：将数据库记录置为已同步，并删除本地沙盒图片释放内存
 */
export const startSyncQueue = async () => {
  console.log('[Sync] startSyncQueue 进入，当前同步状态:', {
    isSyncing,
  });
  if (isSyncing) {
    console.warn('[Sync] 同步队列已在执行中，本次跳过');
    return;
  }

  // 简单判断当前网络是否可用
  const networkType = await getCurrentNetworkType();
  console.log('[Sync] 当前网络状态:', networkType);

  if (networkType === 'none') {
    console.warn('[Sync] 当前离线，跳过同步队列');
    return;
  }

  isSyncing = true;

  try {
    let pendingRecords = [];
    try {
      pendingRecords = await getPendingSyncRecords();
      console.log('[Sync] 读取到待同步记录:', {
        count: pendingRecords.length,
        records: pendingRecords.map((record) => ({
          id: record.id,
          type: record.type,
          localImgPath: record.local_img_path,
          createTime: record.create_time,
        })),
      });
    } catch (dbErr) {
      console.error('[Sync] 读取待同步记录失败:', dbErr);
      return;
    }

    if (pendingRecords.length === 0) {
      console.warn('[Sync] 当前没有待同步记录');
      return;
    }

    // 分类待同步数据
    const signinDataToPull = [];
    const signoutDataToPull = [];
    const recordsToSync = [];

    for (let record of pendingRecords) {
      // 如果创建时间距离当前超过 5 分钟，认为是离线堆积的旧数据，走批量 pull 接口
      const isOfflineOldData = Date.now() - record.create_time > 5 * 60 * 1000;

      try {
        let payload = {
          ...(record.payload || {}),
        };

        // 1. 如果存在本地图片，先上传图片，再把云端地址回填到业务 payload
        if (record.local_img_path) {
          console.log('[Sync] 开始上传本地图片:', {
            recordId: record.id,
            type: record.type,
            localImgPath: record.local_img_path,
          });
          const uploadRes = await uploadImage(record.local_img_path);
          console.log('[Sync] 图片上传结果:', {
            recordId: record.id,
            type: record.type,
            localImgPath: record.local_img_path,
            uploadRes,
          });
          if (uploadRes && uploadRes.code === 200 && uploadRes.url) {
            // 根据记录类型，将云端 URL 赋值给不同的业务 payload 字段
            if (record.type === 'signout') {
              payload.signImageUrl = uploadRes.url;
            } else {
              payload.faceImageUrl = uploadRes.url;
            }
          } else {
            throw new Error('图片上传失败');
          }
        }

        if (isOfflineOldData) {
          // 离线旧数据收集到数组中，准备批量提交
          if (record.type === 'signout') {
             signoutDataToPull.push({ recordId: record.id, localImgPath: record.local_img_path, payload });
          } else {
             signinDataToPull.push({ recordId: record.id, localImgPath: record.local_img_path, payload });
          }
        } else {
           // 实时/较新的数据走单条实时接口
           recordsToSync.push({ recordId: record.id, localImgPath: record.local_img_path, type: record.type, payload });
        }
      } catch (innerErr) {
        console.error(`[Sync] 处理记录 ${record.id} 的图片或数据时失败:`, innerErr);
        // 如果处理单条前置（如传图）失败，跳过该条，等待下次轮询
      }
    }

    // 2. 提交实时单条业务数据
    for (let item of recordsToSync) {
      try {
        let submitRes;
        if (item.type === 'signout') {
          console.log('[Sync] 开始调用签离接口:', {
            recordId: item.recordId,
            payload: item.payload,
          });
          submitRes = await idCardSingOut(item.payload);

        //   await new Promise((resolve) => {
        //     uni.showModal({
        //       title: '调试: 签离接口返回',
        //       content: `记录ID: ${item.recordId}\n结果: ${JSON.stringify(submitRes).substring(0, 500)}`,
        //       showCancel: false,
        //       success: resolve,
        //       fail: resolve
        //     });
        //   });
        } else {
          // type 为 appointment, online, 或它们加上 _signedout 后缀时，都作为进场记录同步
          console.log('[Sync] 开始调用登记接口:', {
            recordId: item.recordId,
            type: item.type,
            payload: item.payload,
          });
          submitRes = await addVisitorRecord(item.payload);

        //   await new Promise((resolve) => {
        //     uni.showModal({
        //       title: '调试: 登记接口返回',
        //       content: `类型: ${item.type}\n记录ID: ${item.recordId}\n结果: ${JSON.stringify(submitRes).substring(0, 500)}`,
        //       showCancel: false,
        //       success: resolve,
        //       fail: resolve
        //     });
        //   });
        }

        console.log('[Sync] 单条业务接口返回:', {
          recordId: item.recordId,
          type: item.type,
          submitRes,
        });

        if (submitRes && submitRes.code === 200) {
          await markRecordSynced(item.recordId);
          if (item.localImgPath) await deleteLocalImage(item.localImgPath);
        }
      } catch (err) {
        console.error(`[Sync] 单条同步 ${item.recordId} 失败:`, err);
      }
    }

    // 3. 提交离线批量签到数据
    if (signinDataToPull.length > 0) {
       try {
         const payloads = signinDataToPull.map(item => item.payload);
         console.log('[Sync] 开始调用批量补发签到接口:', {
           count: payloads.length,
           payloads,
         });
         const pullRes = await pullSigninData(payloads);
         console.log('[Sync] 批量补发签到接口结果:', pullRes);
         if (pullRes && pullRes.code === 200) {
            for (let item of signinDataToPull) {
               await markRecordSynced(item.recordId);
               if (item.localImgPath) await deleteLocalImage(item.localImgPath);
            }
         }
       } catch (err) {
         console.error('[Sync] 批量补发签到数据失败:', err);
       }
    }

    // 4. 提交离线批量签离数据
    if (signoutDataToPull.length > 0) {
       try {
         const payloads = signoutDataToPull.map(item => item.payload);
         console.log('[Sync] 开始调用批量补发签离接口:', {
           count: payloads.length,
           payloads,
         });
         const pullRes = await pullSignoutData(payloads);
         console.log('[Sync] 批量补发签离接口结果:', pullRes);
         if (pullRes && pullRes.code === 200) {
            for (let item of signoutDataToPull) {
               await markRecordSynced(item.recordId);
               if (item.localImgPath) await deleteLocalImage(item.localImgPath);
            }
         }
       } catch (err) {
         console.error('[Sync] 批量补发签离数据失败:', err);
       }
    }

  } catch (error) {
    console.error('[Sync] 队列执行异常:', error);
  } finally {
    isSyncing = false;
  }
};

/**
 * 手动触发全量离线同步：
 * 持续执行同步队列，直到待同步记录清空，或检测到本轮没有任何推进为止。
 */
export const syncAllPendingRecords = async () => {
  if (isSyncing) {
    return {
      success: false,
      reason: 'syncing',
      total: 0,
      synced: 0,
      remaining: await getPendingSyncRecordCount(),
    };
  }

  const networkType = await getCurrentNetworkType();
  if (networkType === 'none') {
    return {
      success: false,
      reason: 'offline',
      total: 0,
      synced: 0,
      remaining: await getPendingSyncRecordCount(),
    };
  }

  const totalPending = await getPendingSyncRecordCount();
  if (totalPending === 0) {
    return {
      success: true,
      reason: 'empty',
      total: 0,
      synced: 0,
      remaining: 0,
    };
  }

  let syncedCount = 0;
  let remainingCount = totalPending;
  let round = 0;
  const maxRounds = 20;

  while (remainingCount > 0 && round < maxRounds) {
    const beforeCount = await getPendingSyncRecordCount();
    if (beforeCount <= 0) {
      remainingCount = 0;
      break;
    }

    await startSyncQueue();

    const afterCount = await getPendingSyncRecordCount();
    const currentRoundSynced = Math.max(beforeCount - afterCount, 0);
    syncedCount += currentRoundSynced;
    remainingCount = afterCount;
    round += 1;

    // 本轮没有任何推进，说明存在上传失败或脏数据，避免死循环卡死按钮。
    if (afterCount >= beforeCount) {
      break;
    }
  }

  return {
    success: remainingCount === 0,
    reason: remainingCount === 0 ? 'completed' : 'partial',
    total: totalPending,
    synced: syncedCount,
    remaining: remainingCount,
  };
};

/**
 * 每日凌晨或空闲时清理超期废弃数据并同步最新配置字典
 */
export const runDailyCleanup = async () => {
  // 1. 清理过期业务记录
  cleanOldRecords().catch(err => {
    console.error('[Sync] 清理过期记录失败:', err);
  });

  // 2. 定点同步访问区域树等配置数据
  try {
    const networkType = await new Promise(resolve => {
      uni.getNetworkType({
        success: (res) => resolve(res.networkType)
      });
    });
    if (networkType !== 'none') {
      const res = await getVisitAreaTree();
      if (res && res.code === 200 && Array.isArray(res.data)) {
        await saveOfflineConfig('visit_area_tree', res.data);
      }
    }
  } catch (err) {
    console.error('[Sync] 每日同步访问区域树失败:', err);
  }
};