/**
 * 스케줄 서비스
 * 스케줄 관련 비즈니스 로직
 */
import config, { CATEGORY_IDS, DEBUT_DATE } from '../config/index.js';
import { getOrSet, cacheKeys, TTL } from '../utils/cache.js';

// ==================== 공통 포맷팅 함수 ====================

/**
 * 날짜 문자열 정규화
 * @param {Date|string} date - 날짜
 * @returns {string} YYYY-MM-DD 형식
 */
export function normalizeDate(date) {
  if (!date) return '';
  if (date instanceof Date) {
    return date.toISOString().split('T')[0];
  }
  return String(date).split('T')[0];
}

/**
 * datetime 생성 (date + time)
 * @param {Date|string} date - 날짜
 * @param {string} time - 시간 (HH:mm:ss)
 * @returns {string} YYYY-MM-DDTHH:mm:ss 또는 YYYY-MM-DD
 */
export function buildDatetime(date, time) {
  const dateStr = normalizeDate(date);
  return time ? `${dateStr}T${time}` : dateStr;
}

/**
 * source 객체 생성
 * @param {object} schedule - 일정 원본 데이터
 * @returns {object|null} { name, url } 또는 null
 */
export function buildSource(schedule) {
  const { category_id, youtube_video_id, youtube_video_type, youtube_channel, x_post_id, x_username } = schedule;

  if (category_id === CATEGORY_IDS.YOUTUBE) {
    if (youtube_video_id) {
      const url = youtube_video_type === 'shorts'
        ? `https://www.youtube.com/shorts/${youtube_video_id}`
        : `https://www.youtube.com/watch?v=${youtube_video_id}`;
      return {
        name: youtube_channel || 'YouTube',
        url,
      };
    } else if (youtube_channel) {
      // 예정 일정: video_id 없이 채널 이름만
      return {
        name: youtube_channel,
        url: null,
      };
    }
  }

  if (category_id === CATEGORY_IDS.X && x_post_id) {
    const username = x_username || config.x.defaultUsername;
    return {
      name: username,
      url: `https://x.com/${username}/status/${x_post_id}`,
    };
  }

  if (category_id === CATEGORY_IDS.EVENT && schedule.event_school_name) {
    return {
      name: schedule.event_school_name,
      url: null,
    };
  }

  return null;
}

/**
 * 단일 일정 포맷팅 (공통)
 * @param {object} rawSchedule - DB에서 조회한 원본 일정
 * @param {string[]} members - 멤버 이름 배열
 * @returns {object} 포맷된 일정 객체
 */
export function formatSchedule(rawSchedule, members = []) {
  const result = {
    id: rawSchedule.id,
    title: rawSchedule.title,
    date: normalizeDate(rawSchedule.date),
    datePrecision: rawSchedule.date_precision || 'day',
    time: rawSchedule.time || null,
    category: {
      id: rawSchedule.category_id,
      name: rawSchedule.category_name,
      color: rawSchedule.category_color,
    },
    source: buildSource(rawSchedule),
    members,
  };
  if (rawSchedule.concert_series_id) {
    result.concertSeriesId = rawSchedule.concert_series_id;
  }
  if (rawSchedule.event_subtype) {
    result.eventSubtype = rawSchedule.event_subtype;
    if (rawSchedule.event_school_name) {
      result.schoolName = rawSchedule.event_school_name;
    }
  }
  return result;
}

/**
 * 현재 활동 멤버 수 조회
 * @param {object} db - 데이터베이스 연결
 * @returns {number} 현재 활동 멤버 수
 */
async function getActiveMemberCount(db) {
  const [[{ count }]] = await db.query(
    'SELECT COUNT(*) as count FROM members WHERE is_former = 0'
  );
  return count;
}

/**
 * 멤버 맵 조회 (일정 ID → 멤버 이름 배열)
 * 전체 멤버인 경우 "프로미스나인"으로 대체
 * @param {object} db - 데이터베이스 연결
 * @param {number[]} scheduleIds - 일정 ID 배열
 * @returns {object} { scheduleId: [memberName, ...] }
 */
export async function buildMemberMap(db, scheduleIds) {
  if (!scheduleIds || scheduleIds.length === 0) {
    return {};
  }

  // 현재 활동 멤버 수 조회
  const activeMemberCount = await getActiveMemberCount(db);

  const [scheduleMembers] = await db.query(`
    SELECT sm.schedule_id, m.name
    FROM schedule_members sm
    JOIN members m ON sm.member_id = m.id
    WHERE sm.schedule_id IN (?) AND m.is_former = 0
    ORDER BY m.id
  `, [scheduleIds]);

  const memberMap = {};
  for (const sm of scheduleMembers) {
    if (!memberMap[sm.schedule_id]) {
      memberMap[sm.schedule_id] = [];
    }
    memberMap[sm.schedule_id].push(sm.name);
  }

  // 전체 멤버인 경우 "프로미스나인"으로 대체
  for (const scheduleId of Object.keys(memberMap)) {
    if (memberMap[scheduleId].length === activeMemberCount) {
      memberMap[scheduleId] = ['프로미스나인'];
    }
  }

  return memberMap;
}

/**
 * 일정 목록 포맷팅 (공통)
 * @param {object[]} rawSchedules - DB에서 조회한 원본 일정 배열
 * @param {object} memberMap - 멤버 맵
 * @returns {object[]} 포맷된 일정 배열
 */
export function formatSchedules(rawSchedules, memberMap) {
  return rawSchedules.map(s => formatSchedule(s, memberMap[s.id] || []));
}

// ==================== 카테고리 ====================

/**
 * 카테고리 목록 조회 (캐시 적용)
 * @param {object} db - 데이터베이스 연결
 * @param {object} redis - Redis 클라이언트 (선택적)
 * @returns {array} 카테고리 목록
 */
export async function getCategories(db, redis = null) {
  const fetchCategories = async () => {
    const [categories] = await db.query(
      'SELECT id, name, color, sort_order FROM schedule_categories ORDER BY sort_order ASC, id ASC'
    );
    return categories;
  };

  if (redis) {
    return getOrSet(redis, cacheKeys.categories, fetchCategories, TTL.VERY_LONG);
  }
  return fetchCategories();
}

// ==================== 일정 상세 ====================

/**
 * 일정 상세 조회
 * @param {object} db - 데이터베이스 연결
 * @param {number} id - 일정 ID
 * @param {Function} getXProfile - X 프로필 조회 함수 (선택적)
 * @returns {object|null} 일정 상세 또는 null
 */
export async function getScheduleDetail(db, id, getXProfile = null) {
  const [schedules] = await db.query(`
    SELECT
      s.*,
      c.name as category_name,
      c.color as category_color,
      sy.channel_name as youtube_channel,
      sy.video_id as youtube_video_id,
      sy.video_type as youtube_video_type,
      sx.post_id as x_post_id,
      sx.username as x_username,
      sx.content as x_content,
      sx.image_urls as x_image_urls,
      sx.video_thumbnails as x_video_thumbnails,
      sx.card_data as x_card_data,
      sv.broadcaster as variety_broadcaster,
      sv.replay_url as variety_replay_url,
      svi.medium_url as variety_thumbnail_url,
      se.subtype as event_subtype,
      se.school_name as event_school_name,
      se.post_urls as event_post_urls,
      se.poster_image_ids as event_poster_image_ids,
      ev.id as event_venue_id,
      ev.name as event_venue_name,
      ev.address as event_venue_address,
      ev.road_address as event_venue_road_address,
      ev.lat as event_venue_lat,
      ev.lng as event_venue_lng
    FROM schedules s
    LEFT JOIN schedule_categories c ON s.category_id = c.id
    LEFT JOIN schedule_youtube sy ON s.id = sy.schedule_id
    LEFT JOIN schedule_x sx ON s.id = sx.schedule_id
    LEFT JOIN schedule_variety sv ON s.id = sv.schedule_id
    LEFT JOIN images svi ON sv.thumbnail_id = svi.id
    LEFT JOIN schedule_event se ON s.id = se.schedule_id
    LEFT JOIN event_venues ev ON se.venue_id = ev.id
    WHERE s.id = ?
  `, [id]);

  if (schedules.length === 0) {
    return null;
  }

  const s = schedules[0];

  // 현재 활동 멤버 수 조회
  const activeMemberCount = await getActiveMemberCount(db);

  // 멤버 정보 조회 (탈퇴 멤버 제외)
  const [members] = await db.query(`
    SELECT m.id, m.name
    FROM schedule_members sm
    JOIN members m ON sm.member_id = m.id
    WHERE sm.schedule_id = ? AND m.is_former = 0
    ORDER BY m.id
  `, [id]);

  // 전체 멤버인 경우 "프로미스나인"으로 대체
  const formattedMembers = members.length === activeMemberCount
    ? [{ id: 0, name: '프로미스나인' }]
    : members;

  // 공통 필드
  const result = {
    id: s.id,
    title: s.title,
    date: normalizeDate(s.date),
    datePrecision: s.date_precision || 'day',
    time: s.time || null,
    category: {
      id: s.category_id,
      name: s.category_name,
      color: s.category_color,
    },
    members: formattedMembers,
    createdAt: s.created_at,
    updatedAt: s.updated_at,
  };

  // 카테고리별 추가 필드
  if (s.category_id === CATEGORY_IDS.YOUTUBE) {
    // 채널 이름은 항상 반환 (예정 일정 포함)
    if (s.youtube_channel) {
      result.channelName = s.youtube_channel;
    }
    // video_id가 있는 경우에만 영상 관련 필드 추가
    if (s.youtube_video_id) {
      result.videoId = s.youtube_video_id;
      result.videoType = s.youtube_video_type;
      result.videoUrl = s.youtube_video_type === 'shorts'
        ? `https://www.youtube.com/shorts/${s.youtube_video_id}`
        : `https://www.youtube.com/watch?v=${s.youtube_video_id}`;
    }
  } else if (s.category_id === CATEGORY_IDS.X && s.x_post_id) {
    const username = s.x_username || config.x.defaultUsername;
    result.postId = s.x_post_id;
    result.username = username;
    result.content = s.x_content || null;
    result.imageUrls = s.x_image_urls ? JSON.parse(s.x_image_urls) : [];
    result.videoThumbnails = s.x_video_thumbnails ? JSON.parse(s.x_video_thumbnails) : [];
    result.card = s.x_card_data ? JSON.parse(s.x_card_data) : null;
    result.postUrl = `https://x.com/${username}/status/${s.x_post_id}`;

    if (getXProfile) {
      const profile = await getXProfile(username);
      if (profile) {
        result.profile = {
          username: profile.username,
          displayName: profile.displayName,
          avatarUrl: profile.avatarUrl,
        };
      }
    }
  } else if (s.category_id === CATEGORY_IDS.VARIETY && s.variety_broadcaster) {
    result.broadcaster = s.variety_broadcaster;
    result.replayUrl = s.variety_replay_url || null;
    result.thumbnailUrl = s.variety_thumbnail_url || null;
  } else if (s.category_id === CATEGORY_IDS.EVENT && s.event_subtype) {
    result.subtype = s.event_subtype;
    result.schoolName = s.event_school_name || null;
    result.postUrls = s.event_post_urls
      ? (typeof s.event_post_urls === 'string' ? JSON.parse(s.event_post_urls) : s.event_post_urls)
      : [];

    const posterIds = s.event_poster_image_ids
      ? (typeof s.event_poster_image_ids === 'string' ? JSON.parse(s.event_poster_image_ids) : s.event_poster_image_ids)
      : [];
    if (posterIds.length > 0) {
      const [posterRows] = await db.query(
        `SELECT id, original_url, medium_url, thumb_url FROM images WHERE id IN (?) ORDER BY FIELD(id, ?)`,
        [posterIds, posterIds]
      );
      result.posters = posterRows.map(p => ({
        id: p.id,
        originalUrl: p.original_url,
        mediumUrl: p.medium_url,
        thumbUrl: p.thumb_url,
      }));
    } else {
      result.posters = [];
    }

    if (s.event_venue_id) {
      result.venue = {
        id: s.event_venue_id,
        name: s.event_venue_name,
        address: s.event_venue_address,
        roadAddress: s.event_venue_road_address,
        lat: s.event_venue_lat,
        lng: s.event_venue_lng,
      };
    } else {
      result.venue = null;
    }
  } else if (s.category_id === CATEGORY_IDS.CONCERT) {
    // 콘서트: 시리즈/포스터/장소/세트리스트(곡별 멤버)/굿즈/다른 회차
    const [conRows] = await db.query(`
      SELECT sc.id AS concert_id, sc.series_id,
             cs.title AS series_title, cs.poster_id,
             cv.id AS venue_id, cv.name AS venue_name, cv.address AS venue_address,
             cv.country AS venue_country, cv.lat AS venue_lat, cv.lng AS venue_lng
      FROM schedule_concert sc
      LEFT JOIN concert_series cs ON sc.series_id = cs.id
      LEFT JOIN concert_venues cv ON sc.venue_id = cv.id
      WHERE sc.schedule_id = ?
    `, [id]);

    if (conRows.length > 0) {
      const con = conRows[0];
      result.seriesId = con.series_id;
      result.seriesTitle = con.series_title || null;
      result.activeMemberCount = activeMemberCount; // 유닛/솔로 판별용

      // 포스터
      if (con.poster_id) {
        const [posterRows] = await db.query(
          'SELECT original_url, medium_url, thumb_url FROM images WHERE id = ?',
          [con.poster_id]
        );
        result.poster = posterRows.length > 0 ? {
          originalUrl: posterRows[0].original_url,
          mediumUrl: posterRows[0].medium_url,
          thumbUrl: posterRows[0].thumb_url,
        } : null;
      } else {
        result.poster = null;
      }

      // 장소
      result.venue = con.venue_id ? {
        id: con.venue_id,
        name: con.venue_name,
        address: con.venue_address,
        country: con.venue_country,
        lat: con.venue_lat,
        lng: con.venue_lng,
      } : null;

      // 세트리스트 (이 회차) + 곡별 멤버
      const [songs] = await db.query(
        `SELECT id, order_num, song_name, album_name
         FROM concert_setlists WHERE concert_id = ? ORDER BY order_num ASC`,
        [con.concert_id]
      );
      const memberMap = {};
      if (songs.length > 0) {
        const songIds = songs.map(x => x.id);
        const [allMem] = await db.query(
          `SELECT csm.setlist_id, m.id, m.name
           FROM concert_setlist_members csm JOIN members m ON csm.member_id = m.id
           WHERE csm.setlist_id IN (?) ORDER BY m.id`,
          [songIds]
        );
        for (const row of allMem) {
          (memberMap[row.setlist_id] ||= []).push({ id: row.id, name: row.name });
        }
      }
      result.setlist = songs.map(song => ({
        id: song.id,
        order: song.order_num,
        songName: song.song_name,
        albumName: song.album_name || null,
        members: memberMap[song.id] || [],
      }));

      // 굿즈 + 다른 회차 (시리즈 기준)
      if (con.series_id) {
        const [md] = await db.query(
          `SELECT csm.id, i.original_url, i.medium_url, i.thumb_url
           FROM concert_series_md csm JOIN images i ON csm.image_id = i.id
           WHERE csm.series_id = ? ORDER BY csm.sort_order ASC`,
          [con.series_id]
        );
        result.merchandise = md.map(x => ({
          id: x.id,
          originalUrl: x.original_url,
          mediumUrl: x.medium_url,
          thumbUrl: x.thumb_url,
        }));

        const [rounds] = await db.query(
          `SELECT s2.id AS schedule_id, s2.date, s2.time
           FROM schedule_concert sc2 JOIN schedules s2 ON sc2.schedule_id = s2.id
           WHERE sc2.series_id = ? AND s2.id != ?
           ORDER BY s2.date ASC, s2.time ASC`,
          [con.series_id, id]
        );
        result.otherRounds = rounds.map(r => ({
          scheduleId: r.schedule_id,
          date: normalizeDate(r.date),
          time: r.time ? r.time.substring(0, 5) : null,
        }));
      } else {
        result.merchandise = [];
        result.otherRounds = [];
      }
    }
  }

  return result;
}

// ==================== 일정 목록 조회 ====================

/** 일정 목록 조회용 공통 SQL */
const SCHEDULE_LIST_SQL = `
  SELECT
    s.id,
    s.title,
    s.date,
    s.date_precision,
    s.time,
    s.category_id,
    c.name as category_name,
    c.color as category_color,
    sy.channel_name as youtube_channel,
    sy.video_id as youtube_video_id,
    sy.video_type as youtube_video_type,
    sx.post_id as x_post_id,
    sx.username as x_username,
    scon.series_id as concert_series_id,
    se.subtype as event_subtype,
    se.school_name as event_school_name
  FROM schedules s
  LEFT JOIN schedule_categories c ON s.category_id = c.id
  LEFT JOIN schedule_youtube sy ON s.id = sy.schedule_id
  LEFT JOIN schedule_x sx ON s.id = sx.schedule_id
  LEFT JOIN schedule_concert scon ON s.id = scon.schedule_id
  LEFT JOIN schedule_event se ON s.id = se.schedule_id
`;

/**
 * 월별 일정 조회 (생일 포함)
 * @param {object} db - 데이터베이스 연결
 * @param {number} year - 연도
 * @param {number} month - 월
 * @returns {object} { schedules: [] }
 */
export async function getMonthlySchedules(db, year, month) {
  const startDate = `${year}-${String(month).padStart(2, '0')}-01`;
  const endDate = new Date(year, month, 0).toISOString().split('T')[0];

  // 일정 조회
  const [rawSchedules] = await db.query(
    `${SCHEDULE_LIST_SQL} WHERE s.date BETWEEN ? AND ? ORDER BY s.date ASC, s.time ASC`,
    [startDate, endDate]
  );

  // 멤버 맵 조회
  const memberMap = await buildMemberMap(db, rawSchedules.map(s => s.id));

  // 일정 포맷팅
  const schedules = formatSchedules(rawSchedules, memberMap);

  // 특수 카테고리 조회 (생일, 기념일)
  const [specialCategories] = await db.query(
    'SELECT id, name, color FROM schedule_categories WHERE id IN (?, ?)',
    [CATEGORY_IDS.BIRTHDAY, CATEGORY_IDS.DEBUT]
  );
  const categoryMap = {};
  for (const cat of specialCategories) {
    categoryMap[cat.id] = { id: cat.id, name: cat.name, color: cat.color };
  }

  // 생일 조회 및 추가
  const [birthdays] = await db.query(`
    SELECT m.id, m.name, m.name_en, m.birth_date,
           i.thumb_url as image_url
    FROM members m
    LEFT JOIN images i ON m.image_id = i.id
    WHERE m.is_former = 0 AND MONTH(m.birth_date) = ?
  `, [month]);

  for (const member of birthdays) {
    const birthDate = new Date(member.birth_date);
    if (year < birthDate.getFullYear()) continue;

    const birthdayDate = new Date(year, birthDate.getMonth(), birthDate.getDate());

    schedules.push({
      id: `birthday-${year}-${member.name_en.toLowerCase()}`,
      title: `HAPPY ${member.name_en} DAY`,
      date: birthdayDate.toISOString().split('T')[0],
      time: null,
      category: categoryMap[CATEGORY_IDS.BIRTHDAY],
      source: null,
      members: [member.name],
      is_birthday: true,
      member_image: member.image_url,
    });
  }

  // 데뷔/주년 추가 (1월인 경우)
  if (month === DEBUT_DATE.month) {
    const debutYear = DEBUT_DATE.year;
    const anniversaryYear = year - debutYear;

    if (year >= debutYear) {
      const debutDate = new Date(year, DEBUT_DATE.month - 1, DEBUT_DATE.day);

      if (year === debutYear) {
        // 데뷔 당일
        schedules.push({
          id: `debut-${year}`,
          title: '프로미스나인 데뷔',
          date: debutDate.toISOString().split('T')[0],
          time: null,
          category: categoryMap[CATEGORY_IDS.DEBUT],
          source: null,
          members: ['프로미스나인'],
          is_debut: true,
        });
      } else {
        // N주년
        schedules.push({
          id: `anniversary-${year}`,
          title: `프로미스나인 데뷔 ${anniversaryYear}주년`,
          date: debutDate.toISOString().split('T')[0],
          time: null,
          category: categoryMap[CATEGORY_IDS.DEBUT],
          source: null,
          members: ['프로미스나인'],
          is_anniversary: true,
          anniversary_year: anniversaryYear,
        });
      }
    }
  }

  // 날짜순 정렬 (같은 날짜 내에서 특수 일정을 먼저 배치)
  schedules.sort((a, b) => {
    // 날짜 비교
    const dateCompare = a.date.localeCompare(b.date);
    if (dateCompare !== 0) return dateCompare;

    // 같은 날짜면 특수 일정(생일, 기념일)을 먼저
    const aSpecial = a.is_birthday || a.is_debut || a.is_anniversary;
    const bSpecial = b.is_birthday || b.is_debut || b.is_anniversary;
    if (aSpecial && !bSpecial) return -1;
    if (!aSpecial && bSpecial) return 1;

    // 둘 다 특수 일정이면 기념일 > 생일 순서
    if (aSpecial && bSpecial) {
      const aDebut = a.is_debut || a.is_anniversary;
      const bDebut = b.is_debut || b.is_anniversary;
      if (aDebut && !bDebut) return -1;
      if (!aDebut && bDebut) return 1;
    }

    // 시간순 정렬
    if (a.time && b.time) return a.time.localeCompare(b.time);
    if (a.time) return -1;
    if (b.time) return 1;

    return 0;
  });

  return { schedules };
}

/**
 * 다가오는 일정 조회
 * @param {object} db - 데이터베이스 연결
 * @param {string} startDate - 시작 날짜
 * @param {number} limit - 조회 개수
 * @returns {object} { schedules: [] }
 */
export async function getUpcomingSchedules(db, startDate, limit) {
  // 일정 조회
  const [rawSchedules] = await db.query(
    `${SCHEDULE_LIST_SQL} WHERE s.date >= ? ORDER BY s.date ASC, s.time ASC LIMIT ?`,
    [startDate, limit]
  );

  // 멤버 맵 조회
  const memberMap = await buildMemberMap(db, rawSchedules.map(s => s.id));

  // 일정 포맷팅
  const schedules = formatSchedules(rawSchedules, memberMap);

  return { schedules };
}
