// GDPR Article 25: Data Protection by Design
// 인증 시스템에서 개인정보 최소 수집 원칙 적용
 
interface GdprCompliantUserData {
  // 필수: 인증에 꼭 필요한 정보만 수집
  id: string;
  email: string;
  passwordHash: string;
 
  // 선택: 명시적 동의 후에만 수집
  name?: string;
  phoneNumber?: string;
 
  // GDPR 관련 메타데이터
  consentGiven: boolean;
  consentTimestamp: Date;
  consentVersion: string;   // 동의한 약관 버전
  dataProcessingBasis: "consent" | "legitimate_interest" | "contract";
}
 
// GDPR Article 17: 잊혀질 권리 (삭제 요청 처리)
async function handleDeletionRequest(userId: string): Promise<void> {
  // 1. 사용자 인증 데이터 삭제
  await deleteUserCredentials(userId);
 
  // 2. 세션/토큰 전체 무효화
  await revokeAllSessions(userId);
  await revokeAllTokens(userId);
 
  // 3. 개인 식별 정보 삭제 또는 익명화
  await anonymizeUserData(userId);
 
  // 4. 감사 로그는 보존 (법적 의무)
  // 단, 개인 식별 정보는 익명화
  await anonymizeAuditLogs(userId);
 
  // 5. 삭제 완료 기록
  await logDeletionRequest(userId, new Date());
}
 
// GDPR Article 20: 데이터 이동권
async function exportUserData(userId: string): Promise<UserDataExport> {
  const userData = await getUserById(userId);
  const authHistory = await getAuthHistory(userId);
  const consentRecords = await getConsentRecords(userId);
 
  return {
    personalData: {
      email: userData.email,
      name: userData.name,
      createdAt: userData.createdAt,
    },
    authenticationHistory: authHistory.map((entry) => ({
      timestamp: entry.timestamp,
      method: entry.method,
      success: entry.success,
      ipAddress: entry.ipAddress, // 개인정보에 해당
    })),
    consentHistory: consentRecords,
    exportedAt: new Date(),
    format: "JSON",
  };
}

// PCI-DSS Requirement 8: 인증 관련 주요 요구사항
 
interface PciCompliantPasswordPolicy {
  // 8.3.6: 최소 12자 (또는 시스템이 지원하지 않으면 8자)
  minLength: 12;
 
  // 8.3.6: 숫자 + 알파벳 포함
  requireNumeric: true;
  requireAlphabetic: true;
 
  // 8.3.7: 지난 4개 비밀번호와 동일 불가
  passwordHistory: 4;
 
  // 8.3.9: 90일마다 변경 (MFA 미사용 시)
  // NIST는 주기적 변경을 권장하지 않지만, PCI-DSS는 아직 요구
  maxAgeDays: 90;
 
  // 8.3.4: 6회 실패 시 계정 잠금
  maxFailedAttempts: 6;
  lockoutDurationMinutes: 30;
}
 
// PCI-DSS 8.4: 카드 데이터 접근 시 MFA 필수
interface PciMfaRequirement {
  // 관리 콘솔 접근 시 MFA 필수
  adminAccess: "mfa_required";
  // 카드 데이터 환경(CDE) 원격 접근 시 MFA 필수
  remoteAccessToCde: "mfa_required";
  // 비콘솔(네트워크) 관리 접근 시 MFA 필수
  nonConsoleAdminAccess: "mfa_required";
}
 
// PCI-DSS 8.6: 시스템 계정/서비스 계정 관리
async function validateServiceAccount(
  accountId: string,
): Promise<ComplianceResult> {
  const account = await getServiceAccount(accountId);
  const issues: string[] = [];
 
  // 대화형 로그인이 가능한 서비스 계정은 금지
  if (account.interactiveLoginAllowed) {
    issues.push("서비스 계정의 대화형 로그인이 허용되어 있습니다.");
  }
 
  // 비밀번호/키의 정기 로테이션 확인
  const daysSinceRotation = daysBetween(
    account.lastKeyRotation,
    new Date()
  );
  if (daysSinceRotation > 90) {
    issues.push(`키 로테이션이 ${daysSinceRotation}일 전에 수행되었습니다.`);
  }
 
  return {
    compliant: issues.length === 0,
    issues,
    checkedAt: new Date(),
  };
}

// PCI-DSS Requirement 10: 모든 접근 추적 및 모니터링
 
interface PciAuditEvent {
  // 10.2.1: 누가
  userId: string;
  userName: string;
 
  // 10.2.1: 무엇을
  eventType:
    | "login_success"
    | "login_failure"
    | "logout"
    | "privilege_escalation"
    | "account_creation"
    | "account_modification"
    | "account_deletion"
    | "password_change"
    | "mfa_enrollment"
    | "data_access"
    | "admin_action";
 
  // 10.2.1: 언제
  timestamp: Date;
 
  // 10.2.1: 어디서
  sourceIp: string;
  userAgent: string;
 
  // 10.2.1: 어떤 리소스에
  resourceType: string;
  resourceId: string;
 
  // 결과
  outcome: "success" | "failure";
  reason?: string;
}
 
// 10.5: 감사 로그 무결성 보호
class TamperProofAuditLog {
  private previousHash: string = "";
 
  async writeEvent(event: PciAuditEvent): Promise<void> {
    // 각 로그 엔트리에 이전 엔트리의 해시를 포함 (체인)
    const entry = {
      ...event,
      previousHash: this.previousHash,
      entryHash: "",
    };
 
    // 현재 엔트리의 해시 계산
    entry.entryHash = await this.calculateHash(entry);
    this.previousHash = entry.entryHash;
 
    // 쓰기 전용 저장소에 기록
    await appendToImmutableStore(entry);
  }
 
  private async calculateHash(entry: object): Promise<string> {
    const data = JSON.stringify(entry);
    const encoder = new TextEncoder();
    const hashBuffer = await crypto.subtle.digest(
      "SHA-256",
      encoder.encode(data),
    );
    return Array.from(new Uint8Array(hashBuffer))
      .map((b) => b.toString(16).padStart(2, "0"))
      .join("");
  }
}

// SOC 2 CC6.3: 정기적 접근 리뷰 자동화
 
interface AccessReviewItem {
  userId: string;
  userName: string;
  department: string;
  roles: string[];
  lastLogin: Date | null;
  lastReviewDate: Date;
  reviewer: string;
  status: "pending" | "approved" | "revoked" | "expired";
}
 
async function generateAccessReview(): Promise<AccessReviewItem[]> {
  const allUsers = await getAllActiveUsers();
  const reviewItems: AccessReviewItem[] = [];
 
  for (const user of allUsers) {
    // 90일 이상 로그인하지 않은 계정 플래그
    const isInactive = user.lastLogin
      ? daysBetween(user.lastLogin, new Date()) > 90
      : true;
 
    // 권한이 부서/역할에 맞지 않는 경우 플래그
    const expectedRoles = await getExpectedRoles(
      user.department,
      user.jobTitle,
    );
    const hasExcessRoles = user.roles.some(
      (role) => !expectedRoles.includes(role)
    );
 
    if (isInactive || hasExcessRoles) {
      reviewItems.push({
        userId: user.id,
        userName: user.name,
        department: user.department,
        roles: user.roles,
        lastLogin: user.lastLogin,
        lastReviewDate: user.lastAccessReview,
        reviewer: user.manager ?? "security-team",
        status: "pending",
      });
    }
  }
 
  return reviewItems;
}
 
// 퇴직자 접근 즉시 해제
async function handleEmployeeOffboarding(
  employeeId: string,
): Promise<void> {
  // 1. 모든 활성 세션 종료
  await terminateAllSessions(employeeId);
 
  // 2. 모든 토큰 폐기
  await revokeAllTokens(employeeId);
 
  // 3. 계정 비활성화 (삭제가 아닌 비활성화)
  await deactivateAccount(employeeId);
 
  // 4. 패스키/보안 키 등록 해제
  await removeAllCredentials(employeeId);
 
  // 5. 서드파티 앱 연동 해제
  await revokeAllOAuthGrants(employeeId);
 
  // 6. 감사 로그 기록
  await logAuditEvent({
    eventType: "account_deactivation",
    userId: employeeId,
    reason: "employee_offboarding",
    performedBy: "hr-system",
    timestamp: new Date(),
  });
}

interface PasswordValidationResult {
  valid: boolean;
  errors: string[];
}
 
async function validatePassword(
  password: string,
  userId: string,
): Promise<PasswordValidationResult> {
  const errors: string[] = [];
 
  // NIST: 최소 8자, 최대 제한 없음 (64자 이상 허용)
  if (password.length < 8) {
    errors.push("비밀번호는 최소 8자 이상이어야 합니다.");
  }
 
  // NIST: 유출된 비밀번호 차단 (Have I Been Pwned API 등)
  const isBreached = await checkBreachedPasswords(password);
  if (isBreached) {
    errors.push(
      "이 비밀번호는 데이터 유출에서 발견되었습니다. 다른 비밀번호를 사용해주세요."
    );
  }
 
  // NIST: 컨텍스트 기반 차단
  const user = await getUserById(userId);
  const contextWords = [
    user.email.split("@")[0],
    user.name,
    "password",
    "12345678",
  ].filter(Boolean);
 
  for (const word of contextWords) {
    if (password.toLowerCase().includes(word.toLowerCase())) {
      errors.push("비밀번호에 개인정보나 일반적인 단어를 포함할 수 없습니다.");
      break;
    }
  }
 
  // NIST: 공백 허용, 유니코드 허용
  // 복잡성 규칙 (대문자/소문자/숫자/특수문자 강제)은 적용하지 않음
 
  return {
    valid: errors.length === 0,
    errors,
  };
}
 
// Have I Been Pwned API를 활용한 유출 비밀번호 확인
async function checkBreachedPasswords(
  password: string,
): Promise<boolean> {
  const hash = await sha1(password);
  const prefix = hash.substring(0, 5);
  const suffix = hash.substring(5).toUpperCase();
 
  // k-Anonymity: 해시의 앞 5자만 전송
  const response = await fetch(
    `https://api.pwnedpasswords.com/range/${prefix}`
  );
  const text = await response.text();
 
  // 응답에서 나머지 해시 매칭 확인
  return text.split("\n").some((line) => line.startsWith(suffix));
}

interface MfaPolicy {
  // 어떤 상황에서 MFA를 요구하는가
  triggers: MfaTrigger[];
  // 허용하는 MFA 방식
  allowedMethods: MfaMethod[];
  // 금지하는 MFA 방식
  prohibitedMethods: MfaMethod[];
}
 
type MfaTrigger =
  | "all_logins"           // 모든 로그인
  | "admin_access"         // 관리자 접근
  | "sensitive_data"       // 민감 데이터 접근
  | "new_device"           // 새 디바이스
  | "unusual_location"     // 비정상 위치
  | "high_risk_action";    // 고위험 작업
 
type MfaMethod =
  | "passkey"              // 패스키 (가장 강력)
  | "security_key"         // 하드웨어 보안 키
  | "authenticator_app"    // TOTP 앱
  | "push_notification"    // 푸시 알림
  | "sms_otp"              // SMS OTP
  | "email_otp";           // 이메일 OTP
 
const regulatoryMfaPolicies: Record<string, MfaPolicy> = {
  "pci-dss": {
    triggers: ["admin_access", "sensitive_data"],
    allowedMethods: [
      "passkey",
      "security_key",
      "authenticator_app",
      "push_notification",
    ],
    // PCI-DSS 4.0: SMS는 피싱 위험으로 비권장
    prohibitedMethods: ["sms_otp"],
  },
  "soc2": {
    triggers: [
      "admin_access",
      "new_device",
      "unusual_location",
    ],
    allowedMethods: [
      "passkey",
      "security_key",
      "authenticator_app",
      "push_notification",
      "sms_otp",
    ],
    prohibitedMethods: [],
  },
  "nist-aal2": {
    triggers: ["all_logins"],
    allowedMethods: [
      "passkey",
      "security_key",
      "authenticator_app",
    ],
    // NIST AAL2: SMS OTP는 RESTRICTED (제한적 허용)
    prohibitedMethods: ["email_otp"],
  },
};

interface ComplianceCheckResult {
  category: string;
  requirement: string;
  status: "pass" | "fail" | "partial" | "not_applicable";
  evidence: string;
  remediation?: string;
}
 
async function runComplianceCheck(): Promise<ComplianceCheckResult[]> {
  const results: ComplianceCheckResult[] = [];
 
  // 인증 정책
  results.push(await checkMfaEnforcement());
  results.push(await checkPasswordPolicy());
  results.push(await checkSessionTimeout());
  results.push(await checkAccountLockout());
 
  // 접근 제어
  results.push(await checkRbacImplementation());
  results.push(await checkLeastPrivilege());
  results.push(await checkAccessReviewProcess());
  results.push(await checkOffboardingProcess());
 
  // 로깅과 모니터링
  results.push(await checkAuditLogCompleteness());
  results.push(await checkLogRetention());
  results.push(await checkLogIntegrity());
  results.push(await checkAlertConfiguration());
 
  // 데이터 보호
  results.push(await checkEncryptionAtRest());
  results.push(await checkEncryptionInTransit());
  results.push(await checkDataResidency());
 
  // 인증서/키 관리
  results.push(await checkCertificateExpiry());
  results.push(await checkKeyRotation());
  results.push(await checkSecretManagement());
 
  return results;
}