// Calendar.tsx（カレンダーグリッドの組み立て）
const daysInMonth = getDaysInMonth(year, month);
const firstDayOfWeek = getFirstDayOfMonth(year, month);
const totalCells = 42; // 6 weeks x 7 days
const cells: CalendarCell[] = Array.from({ length: totalCells }, (_, i) => {
  const dayOffset = i - firstDayOfWeek + 1;

  // 前月の日付
  if (dayOffset <= 0) {
    const prevMonth = month === 1 ? 12 : month - 1;
    const prevYear = month === 1 ? year - 1 : year;
    const prevMonthDays = getDaysInMonth(prevYear, prevMonth);
    return { day: prevMonthDays + dayOffset, isPrevMonth: true, isCurrentMonth: false, isNextMonth: false };
  }

  // 翌月の日付
  if (dayOffset > daysInMonth) {
    return { day: dayOffset - daysInMonth, isPrevMonth: false, isCurrentMonth: false, isNextMonth: true };
  }

  // 当月の日付
  return { day: dayOffset, isPrevMonth: false, isCurrentMonth: true, isNextMonth: false };
});

-- 日付データ
create table day_data (
  id uuid primary key default gen_random_uuid(),
  user_id uuid references auth.users not null,
  date date not null,
  created_at timestamptz default now(),
  unique (user_id, date)
);

-- スタンプデータ
create table stamps (
  id uuid primary key default gen_random_uuid(),
  day_data_id uuid references day_data(id) on delete cascade not null,
  stamp_id text not null,         -- "mood_great" など
  comment text,                   -- 暗号化されたコメント
  sort_order int not null default 0,
  created_at timestamptz default now()
);

-- インデックス
create index on stamps(day_data_id);
create index on day_data(user_id);

-- day_data: 自分のデータのみ操作可能
create policy "own data only" on day_data
  for all using (auth.uid() = user_id);

-- stamps: 自分のday_dataに紐づくスタンプのみ
create policy "own stamps only" on stamps
  for all using (
    exists (
      select 1 from day_data
      where day_data.id = stamps.day_data_id
        and day_data.user_id = auth.uid()
    )
  );

const { calendarData, syncing, addStamp, deleteStamp, updateComment } = useCalendarData(userId, year, month);

// addStamp の流れ（簡略）
setCalendarData(newData); // 先にUIを更新

try {
  await supabase.from('stamps').insert({ ... });
} catch {
  setCalendarData(calendarData); // 失敗したら元の状態に戻す
}

const deleteStamp = async (date: string, stampId: string) => {
  // ... stamps を削除

  // スタンプが0枚になったらday_dataも削除
  const { count } = await supabase
    .from('stamps')
    .select('*', { count: 'exact', head: true })
    .eq('day_data_id', dayDataId);

  if ((count ?? 1) === 0) {
    await supabase.from('day_data').delete().eq('id', dayDataId);
  }
};

// utils/crypto.ts

const PBKDF2_ITERATIONS = 100000;

// ユーザーIDとランダムなsaltからPBKDF2で鍵を派生
async function deriveKey(userId: string, salt: Uint8Array): Promise<CryptoKey> {
  const raw = new TextEncoder().encode(userId);
  const base = await crypto.subtle.importKey('raw', raw, 'PBKDF2', false, ['deriveKey']);
  return crypto.subtle.deriveKey(
    { name: 'PBKDF2', salt, iterations: PBKDF2_ITERATIONS, hash: 'SHA-256' },
    base,
    { name: 'AES-GCM', length: 256 },
    false,
    ['encrypt', 'decrypt']
  );
}

// 暗号化: salt(16B) + iv(12B) + ciphertext をバイナリ連結して1つのBase64文字列で返す
export async function encryptComment(text: string, userId: string): Promise<string> {
  if (!text) return '';
  const salt = crypto.getRandomValues(new Uint8Array(16));
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const key = await deriveKey(userId, salt);
  const cipher = await crypto.subtle.encrypt(
    { name: 'AES-GCM', iv },
    key,
    new TextEncoder().encode(text)
  );
  const combined = new Uint8Array(salt.byteLength + iv.byteLength + cipher.byteLength);
  combined.set(salt, 0);
  combined.set(iv, salt.byteLength);
  combined.set(new Uint8Array(cipher), salt.byteLength + iv.byteLength);
  return btoa(String.fromCharCode(...combined));
}

// 復号: 失敗したら元の文字列をそのまま返す
export async function decryptComment(encrypted: string, userId: string): Promise<string> {
  if (!encrypted) return '';
  try {
    const combined = Uint8Array.from(atob(encrypted), c => c.charCodeAt(0));
    const salt = combined.slice(0, 16);
    const iv = combined.slice(16, 28);
    const cipher = combined.slice(28);
    const key = await deriveKey(userId, salt);
    const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, cipher);
    return new TextDecoder().decode(decrypted);
  } catch {
    return encrypted;
  }
}

/* リングが 30s で時計回り → 絵文字は 30s で反時計回り */
@keyframes orbitA { from { transform: rotate(  0deg) } to { transform: rotate( 360deg) } }
@keyframes cntA   { from { transform: rotate(  0deg) } to { transform: rotate(-360deg) } }

style={{ fontSize: "clamp(0.6rem, 2.5vw, 1.125rem)" }}

{open && (
  <>
    {/* 全画面の透明 div をポップアップの後ろに敷く */}
    <div className="fixed inset-0 z-10" onClick={() => setOpen(false)} />
    <div className="absolute z-20 ...">
      {/* ポップアップ本体 */}
    </div>
  </>
)}

// StampComment コンポーネント内
const [comment, setComment] = useState(stamp.comment);
const [saveStatus, setSaveStatus] = useState<'idle' | 'saving' | 'saved'>('idle');
const debounceTimer = useRef<ReturnType<typeof setTimeout> | null>(null);

const handleChange = (value: string) => {
  setComment(value);
  setSaveStatus('saving');

  if (debounceTimer.current) clearTimeout(debounceTimer.current);

  debounceTimer.current = setTimeout(() => {
    onUpdateComment(stamp.id, value);
    setSaveStatus('saved');
    setTimeout(() => setSaveStatus('idle'), 2000);
  }, 500);
};

const securityHeaders = [
  { key: 'X-Frame-Options', value: 'DENY' },
  { key: 'X-Content-Type-Options', value: 'nosniff' },
  { key: 'Referrer-Policy', value: 'strict-origin-when-cross-origin' },
  {
    key: 'Strict-Transport-Security',
    value: 'max-age=63072000; includeSubDomains'
  },
  {
    key: 'Permissions-Policy',
    value: 'camera=(), microphone=()'
  },
];

const fetchData = useCallback(async () => {
  // ...
}, [supabase, userId]);

useEffect(() => {
  fetchData();
}, [fetchData]);

const supabase = useMemo(() => createClient(url, key), []);

const { data: dayData } = await supabase
  .from('day_data')
  .upsert(
    { user_id: userId, date: isoDate },
    { onConflict: 'user_id,date' }
  )
  .select()
  .single();

const [theme, setTheme] = useState<Theme>(() => {
  if (typeof window === "undefined") return "turquoise"; // SSR時はデフォルト値を返す
  return (localStorage.getItem("theme") as Theme) || "turquoise";
});

// app/auth/callback/route.ts
export async function GET(request: Request) {
  const code = new URL(request.url).searchParams.get("code");
  if (code) {
    const supabase = createServerClient(...);
    await supabase.auth.exchangeCodeForSession(code); // code → セッションに変換
  }
  return NextResponse.redirect(`${origin}/`);
}