"use server"

import { getErrorMessage } from "@/lib/handle-error"
import { desc, eq } from "drizzle-orm"
import db from "@/db/db"
import { notice, pageInformation, menuAssignments, users } from "@/db/schema"

import type { 
  CreateNoticeSchema, 
  UpdateNoticeSchema
} from "./validations"

import {
  getNoticesByPagePath,
  insertNotice,
  updateNotice,
  deleteNoticeById,
  deleteNoticeByIds,
  getNoticeById
} from "./repository"

import type { Notice } from "@/db/schema/notice"

// 간단한 공지사항 목록 조회 (페이지네이션 없이 전체 조회)
export async function getNoticeLists(): Promise<{ data: Array<Notice & { authorName: string | null; authorEmail: string | null }> }> {
  try {
    // 전체 데이터 조회 (작성자 정보 포함, 클라이언트에서 검색 처리)
    const data = await db
      .select({
        id: notice.id,
        pagePath: notice.pagePath,
        title: notice.title,
        content: notice.content,
        authorId: notice.authorId,
        isActive: notice.isActive,
        createdAt: notice.createdAt,
        updatedAt: notice.updatedAt,
        authorName: users.name,
        authorEmail: users.email,
      })
      .from(notice)
      .leftJoin(users, eq(notice.authorId, users.id))
      .orderBy(desc(notice.createdAt))

    return { data }
  } catch (err) {
    console.error("Failed to get notice lists:", err)
    return { data: [] }
  }
}

// 페이지별 공지사항 조회 (일반 사용자용)
export async function getPageNotices(pagePath: string): Promise<Array<Notice & { authorName: string | null; authorEmail: string | null }>> {
  try {
    console.log('🔍 Notice Service - 조회 시작:', { pagePath })
    const result = await getNoticesByPagePath(pagePath)
    console.log('📊 Notice Service - 조회 결과:', {
      pagePath,
      noticesCount: result.length,
      notices: result.map(n => ({ id: n.id, title: n.title, pagePath: n.pagePath }))
    })
    return result
  } catch (error) {
    console.error(`Failed to get notices for page ${pagePath}:`, error)
    return []
  }
}

// 페이지별 공지사항 조회 (직접 호출용)
export async function getPageNoticesDirect(pagePath: string) {
  return await getPageNotices(pagePath)
}

// 공지사항 생성
export async function createNotice(input: CreateNoticeSchema) {
  try {
    const result = await insertNotice(input)
    
    return {
      success: true,
      data: result,
      message: "공지사항이 성공적으로 생성되었습니다."
    }
  } catch (error) {
    console.error("Failed to create notice:", error)
    return {
      success: false,
      message: getErrorMessage(error)
    }
  }
}

// 공지사항 수정
export async function updateNoticeData(input: UpdateNoticeSchema) {
  try {
    const { id, ...updateData } = input
    const result = await updateNotice(id, updateData)
    
    if (!result) {
      return {
        success: false,
        message: "공지사항을 찾을 수 없거나 수정에 실패했습니다."
      }
    }
    
    return {
      success: true,
      message: "공지사항이 성공적으로 수정되었습니다."
    }
  } catch (error) {
    console.error("Failed to update notice:", error)
    return {
      success: false,
      message: getErrorMessage(error)
    }
  }
}

// 공지사항 삭제
export async function deleteNotice(id: number) {
  try {
    const success = await deleteNoticeById(id)
    
    if (!success) {
      return {
        success: false,
        message: "공지사항을 찾을 수 없거나 삭제에 실패했습니다."
      }
    }
    
    return {
      success: true,
      message: "공지사항이 성공적으로 삭제되었습니다."
    }
  } catch (error) {
    console.error("Failed to delete notice:", error)
    return {
      success: false,
      message: getErrorMessage(error)
    }
  }
}

// 공지사항 다중 삭제
export async function deleteMultipleNotices(ids: number[]) {
  try {
    const deletedCount = await deleteNoticeByIds(ids)
    
    return {
      success: true,
      deletedCount,
      message: `${deletedCount}개의 공지사항이 성공적으로 삭제되었습니다.`
    }
  } catch (error) {
    console.error("Failed to delete multiple notices:", error)
    return {
      success: false,
      message: getErrorMessage(error)
    }
  }
}

// ID로 공지사항 조회
export async function getNoticeDetail(id: number): Promise<(Notice & { authorName: string | null; authorEmail: string | null }) | null> {
  try {
    return await getNoticeById(id)
  } catch (error) {
    console.error(`Failed to get notice detail for id ${id}:`, error)
    return null
  }
}

// pagePath 목록 조회 (정보 시스템에서 사용)
export async function getPagePathList(): Promise<Array<{ pagePath: string; pageName: string }>> {
  try {
    const result = await db
      .selectDistinct({
        pagePath: pageInformation.pagePath,
        pageName: pageInformation.pageName
      })
      .from(pageInformation)
      .where(eq(pageInformation.isActive, true))
      .orderBy(desc(pageInformation.pagePath))

    return result.map(item => ({
      pagePath: item.pagePath,
      pageName: item.pageName || item.pagePath
    }))
  } catch (error) {
    console.error("Failed to get page path list:", error)
    return []
  }
}

// menu_assignments 기반으로 notice 페이지 경로 동기화
export async function syncNoticeFromMenuAssignments() {
  try {
    // menu_assignments에서 모든 메뉴 가져오기
    const menuItems = await db.select().from(menuAssignments);
    
    // 기존 notice 페이지 경로들 가져오기 (중복 제거)
    const existingNotices = await db.select({
      pagePath: notice.pagePath
    }).from(notice);
    const existingPaths = new Set(existingNotices.map(item => item.pagePath));
    
    let processedCount = 0;
    const missingPaths = [];
    
    // 각 메뉴 항목에 대해 확인
    for (const menu of menuItems) {
      if (!existingPaths.has(menu.menuPath)) {
        missingPaths.push({
          pagePath: menu.menuPath,
          pageName: menu.menuTitle
        });
      }
      processedCount++;
    }
    
    return {
      success: true,
      message: `공지사항 경로 동기화 확인 완료: ${processedCount}개 확인, ${missingPaths.length}개 누락`,
      missingPaths: missingPaths
    };
  } catch (error) {
    console.error("Notice 동기화 오류:", error);
    return {
      success: false,
      message: "공지사항 경로 동기화 중 오류가 발생했습니다.",
      missingPaths: []
    };
  }
}