// 알림 타입 배지 토글
document.querySelectorAll('.alert-badge').forEach(badge => {
  badge.addEventListener('click', async () => {
    const type = badge.dataset.type;
    const teamId = badge.closest('[data-team-id]').dataset.teamId;

    badge.classList.toggle('active');

    await fetch(`/api/teams/${teamId}/alert-types`, {
      method: 'PATCH',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ type, enabled: badge.classList.contains('active') }),
    });
  });
});

async function fetchSlackMembers() {
  const res = await fetch('https://slack.com/api/users.list', {
    headers: { Authorization: `Bearer ${BOT_TOKEN}` },
  });
  const data = await res.json();
  return data.members
    .filter(m => !m.is_bot && !m.deleted)
    .map(m => ({
      id: m.id,
      name: m.profile.display_name || m.real_name,
    }));
}

// 버그 있는 코드
select.value = member.slackId;  // 항상 첫 번째로 스냅됨

// 해결: selectedIndex 직접 지정
const idx = [...select.options].findIndex(o => o.value === member.slackId);
if (idx !== -1) select.selectedIndex = idx;

// 크론 재등록 API
app.patch('/api/crons/:id', async (req, res) => {
  const { id } = req.params;
  const { enabled, schedule } = req.body;

  // 기존 크론 중지
  if (cronJobs[id]) {
    cronJobs[id].stop();
    delete cronJobs[id];
  }

  // 설정 저장
  settings.crons[id] = { enabled, schedule };
  await saveSettings();

  // 활성화 상태면 재등록
  if (enabled) {
    cronJobs[id] = cron.schedule(schedule, cronHandlers[id]);
  }

  res.json({ ok: true });
});

services:
  slack-bot:
    build: .
    container_name: slack-bot
    ports:
      - "3001:3000"
    env_file:
      - .env
    volumes:
      - ./data:/app/data
    restart: unless-stopped

LOGIN_ID=포털_아이디
LOGIN_PW=포털_비밀번호
PORT=3000
DATA_DIR=/app/data
TZ=Asia/Seoul

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

# 최초 실행 또는 코드 변경 시
docker compose up -d --build

# .env만 변경 시
docker compose restart

# 로그 확인
docker logs slack-bot -f

# 외부 노출: 슬래시 커맨드, Slack 이벤트
location /slack/ {
    proxy_pass http://localhost:3001;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-Proto $scheme;
}

# 관리자 페이지는 Nginx에 열지 않음
# → Tailscale VPN으로만 접근: http://100.109.108.36:3001/admin

# .env에 추가
TZ=Asia/Seoul

// 해결: webhook 기준으로 dedup
function dedupeByWebhook(teams) {
  const seen = new Set();
  return teams.filter(t => {
    if (seen.has(t.webhook)) return false;
    seen.add(t.webhook);
    return true;
  });
}

// 서버 시작 시 snapshot.json 로드
async function loadSnapshot() {
  try {
    const raw = await fs.readFile(SNAPSHOT_PATH, 'utf8');
    return JSON.parse(raw);
  } catch {
    return { vacations: [], rooms: [], updatedAt: null };
  }
}

{
  "vacations": [
    {
      "id": "unique-key",
      "name": "홍길동",
      "date": "2026-04-03",
      "type": "연차"
    }
  ],
  "rooms": [
    {
      "id": "unique-key",
      "title": "주간 회의",
      "room": "중회의실",
      "start": "2026-04-03T10:00:00",
      "end": "2026-04-03T11:00:00"
    }
  ],
  "updatedAt": "2026-04-03T08:50:00.000Z"
}

function detectChanges(prev, curr, keyFn) {
  const prevMap = new Map(prev.map(item => [keyFn(item), item]));
  const currMap = new Map(curr.map(item => [keyFn(item), item]));

  const added   = curr.filter(item => !prevMap.has(keyFn(item)));
  const removed = prev.filter(item => !currMap.has(keyFn(item)));

  return { added, removed };
}

// 휴가 변동 감지
const vacationChanges = detectChanges(
  snapshot.vacations,
  freshVacations,
  v => `${v.id}_${v.date}`
);

// 회의실 변동 감지
const roomChanges = detectChanges(
  snapshot.rooms,
  freshRooms,
  r => r.id
);

const snapshotDate = snapshot.updatedAt?.slice(0, 10);
const today = new Date().toISOString().slice(0, 10);

// 날짜가 같을 때만 변동 비교 (날짜 변경 시 오탐 방지)
if (snapshotDate === today) {
  const roomChanges = detectChanges(snapshot.rooms, freshRooms, r => r.id);
  if (roomChanges.added.length || roomChanges.removed.length) {
    await notifyRoomChanges(roomChanges);
  }
}

async function saveSnapshot(vacations, rooms) {
  const snapshot = {
    vacations,
    rooms,
    updatedAt: new Date().toISOString(),
  };
  await fs.writeFile(SNAPSHOT_PATH, JSON.stringify(snapshot, null, 2));
}

const cron = require('node-cron');

// 10분마다: 변동 감지
cron.schedule('*/10 * * * *', () => syncAndCheckChanges());

// 월요일 09시: 이번 주 전체 휴가자
cron.schedule('0 9 * * 1', () => sendVacationWeekly());

// 화~금 09시: 당일 휴가자
cron.schedule('0 9 * * 2-5', () => sendVacationDaily());

// 월~금 09시: 당일 회의실 예약
cron.schedule('0 9 * * 1-5', () => sendRoomDaily());

// 월~금 09시: 출근 미등록자 DM
cron.schedule('0 9 * * 1-5', () => sendCommuteAlert());

// 30분마다: 세션 keepalive
cron.schedule('*/30 * * * *', () => keepSession());

// 월요일 00시: 로그 초기화
cron.schedule('0 0 * * 1', () => resetLog());

{
  "crons": {
    "sync":           { "enabled": true,  "schedule": "*/10 * * * *" },
    "vacationWeekly": { "enabled": true,  "schedule": "0 9 * * 1" },
    "vacationDaily":  { "enabled": true,  "schedule": "0 9 * * 2-5" },
    "roomDaily":      { "enabled": true,  "schedule": "0 9 * * 1-5" },
    "commute":        { "enabled": true,  "schedule": "0 9 * * 1-5" },
    "sessionKeep":    { "enabled": true,  "schedule": "*/30 * * * *" },
    "logReset":       { "enabled": true,  "schedule": "0 0 * * 1" }
  }
}

const settings = JSON.parse(await fs.readFile(SETTINGS_PATH));
const cronJobs = {};

for (const [id, config] of Object.entries(settings.crons)) {
  if (!config.enabled) continue;
  cronJobs[id] = cron.schedule(config.schedule, cronHandlers[id]);
}

async function sendWebhook(webhookUrl, message) {
  await axios.post(webhookUrl, { text: message });
}

{
  "teams": [
    {
      "name": "개발팀",
      "webhook": "https://hooks.slack.com/...",
      "enabled": true,
      "alertTypes": {
        "vacationChange": true,
        "vacationDaily": true,
        "roomChange": false,
        "roomDaily": true,
        "commute": false
      },
      "deptIds": ["0001", "0002"]
    }
  ]
}

async function notifyByType(type, message) {
  const teams = settings.teams.filter(
    t => t.enabled && t.alertTypes[type]
  );
  for (const team of teams) {
    await sendWebhook(team.webhook, message);
  }
}

function dedupeByWebhook(teams) {
  const seen = new Set();
  return teams.filter(team => {
    if (seen.has(team.webhook)) return false;
    seen.add(team.webhook);
    return true;
  });
}

async function notifyByType(type, message) {
  const teams = dedupeByWebhook(
    settings.teams.filter(t => t.enabled && t.alertTypes[type])
  );
  for (const team of teams) {
    await sendWebhook(team.webhook, message);
  }
}

app.post('/slack/command', async (req, res) => {
  const { command, text, channel_id } = req.body;

  // Slack에 일단 빈 응답 먼저 → 3초 타임아웃 방지
  res.json({ response_type: 'ephemeral', text: '조회 중...' });

  // 실제 처리는 비동기로
  const result = await handleCommand(command, text, channel_id);
  await axios.post(req.body.response_url, {
    response_type: 'in_channel',
    text: result,
  });
});

function parseDate(text) {
  if (!text || text === '오늘') return [today(), today()];
  if (text === '내일') return [tomorrow(), tomorrow()];
  if (text === '이번주') return [monday(), friday()];
  if (text.includes('~')) {
    const [start, end] = text.split('~').map(s => s.trim());
    return [start, end];
  }
  // 날짜 직접 입력: '2026-04-03'
  return [text.trim(), text.trim()];
}

function getTeamByChannel(channelId) {
  // 1. 채널 ID로 팀 매칭
  const team = teams.find(t => t.channelId === channelId);
  if (team) return team;

  // 2. 실패 시 → 사용자 Slack 이름에서 팀 추출
  // 3. 그것도 실패 시 → 전체 팀 그룹핑해서 표시
  return null;
}