"use server"

import { revalidatePath } from "next/cache"
import db from "@/db/db"
import { codeGroups, comboBoxSettings, documentClasses } from "@/db/schema/docu-list-rule"
import { eq, sql, count } from "drizzle-orm"
import { unstable_noStore } from "next/cache"

// Code Groups 목록 조회
export async function getCodeGroups(input: {
  page: number
  perPage: number
  search?: string
  sort?: Array<{ id: string; desc: boolean }>
  filters?: Array<{ id: string; value: string }>
  joinOperator?: "and" | "or"
  flags?: string[]
  groupId?: string
  description?: string
  controlType?: string
  isActive?: string
} | any) {
  unstable_noStore()
  
  try {
    const { page, perPage, sort, search } = input
    const offset = (page - 1) * perPage

    // 검색 조건 (Document Class 제외)
    let whereConditions = sql`${codeGroups.groupId} != 'DOC_CLASS'`
    if (search) {
      const searchTerm = `%${search}%`
      whereConditions = sql`${codeGroups.groupId} != 'DOC_CLASS' AND (
        ${codeGroups.groupId} ILIKE ${searchTerm} OR
        ${codeGroups.description} ILIKE ${searchTerm} OR
        ${codeGroups.codeFormat} ILIKE ${searchTerm} OR
        ${codeGroups.controlType} ILIKE ${searchTerm}
      )`
    }

    // 정렬
    let orderBy = sql`${codeGroups.createdAt} DESC`
    if (sort && sort.length > 0) {
      const sortField = sort[0]
      const direction = sortField.desc ? sql`DESC` : sql`ASC`
      
      switch (sortField.id) {
        case "groupId":
          orderBy = sql`${codeGroups.groupId} ${direction}`
          break
        case "description":
          orderBy = sql`${codeGroups.description} ${direction}`
          break
        case "codeFormat":
          orderBy = sql`${codeGroups.codeFormat} ${direction}`
          break
        case "controlType":
          orderBy = sql`${codeGroups.controlType} ${direction}`
          break
        case "isActive":
          orderBy = sql`${codeGroups.isActive} ${direction}`
          break
        case "createdAt":
          orderBy = sql`${codeGroups.createdAt} ${direction}`
          break
        default:
          orderBy = sql`${codeGroups.createdAt} DESC`
      }
    }

    // 데이터 조회
    const data = await db
      .select({
        id: codeGroups.id,
        groupId: codeGroups.groupId,
        description: codeGroups.description,
        codeFormat: codeGroups.codeFormat,
        expressions: codeGroups.expressions,
        controlType: codeGroups.controlType,
        isActive: codeGroups.isActive,
        createdAt: codeGroups.createdAt,
        updatedAt: codeGroups.updatedAt,
      })
      .from(codeGroups)
      .where(whereConditions)
      .orderBy(orderBy)
      .limit(perPage)
      .offset(offset)

    // 총 개수 조회 (Document Class 제외)
    const [{ count: total }] = await db
      .select({ count: count() })
      .from(codeGroups)
      .where(whereConditions)

    const pageCount = Math.ceil(total / perPage)

    return {
      data,
      pageCount,
      total,
    }
  } catch (error) {
    console.error("Error fetching code groups:", error)
    return {
      data: [],
      pageCount: 0,
      total: 0,
    }
  }
}

// Code Group 생성
export async function createCodeGroup(input: {
  description: string
  codeFormat?: string
  expressions?: string
  controlType: string
  isActive?: boolean
}) {
  try {
    // 마지막 Code Group의 groupId를 찾아서 다음 번호 생성 (DOC_CLASS 제외)
    const lastCodeGroup = await db
      .select({ groupId: codeGroups.groupId })
      .from(codeGroups)
      .where(sql`${codeGroups.groupId} != 'DOC_CLASS'`)
      .orderBy(sql`CAST(SUBSTRING(${codeGroups.groupId}, 6) AS INTEGER) DESC`)
      .limit(1)

    let nextNumber = 1
    if (lastCodeGroup.length > 0 && lastCodeGroup[0].groupId) {
      const lastNumber = parseInt(lastCodeGroup[0].groupId.replace('Code_', ''))
      if (!isNaN(lastNumber)) {
        nextNumber = lastNumber + 1
      }
    }

    const newGroupId = `Code_${nextNumber}`

    // 새 Code Group 생성
    const [newCodeGroup] = await db
      .insert(codeGroups)
      .values({
        groupId: newGroupId,
        description: input.description,
        codeFormat: input.codeFormat,
        expressions: input.expressions,
        controlType: input.controlType,
        isActive: input.isActive ?? true,
      })
      .returning({ id: codeGroups.id, groupId: codeGroups.groupId })

    revalidatePath("/evcp/docu-list-rule/code-groups")
    
    return {
      success: true,
      data: newCodeGroup,
      message: "Code Group created successfully"
    }
  } catch (error) {
    console.error("Error creating code group:", error)
    return {
      success: false,
      error: "Failed to create code group"
    }
  }
}

// Code Group 수정
export async function updateCodeGroup(input: {
  id: number
  description: string
  codeFormat?: string
  expressions?: string
  controlType: string
  isActive?: boolean
}) {
  try {
    const [updatedCodeGroup] = await db
      .update(codeGroups)
      .set({
        description: input.description,
        codeFormat: input.codeFormat,
        expressions: input.expressions,
        controlType: input.controlType,
        isActive: input.isActive,
        updatedAt: new Date(),
      })
      .where(eq(codeGroups.id, input.id))
      .returning({ id: codeGroups.id })

    revalidatePath("/evcp/docu-list-rule/code-groups")
    
    return {
      success: true,
      data: updatedCodeGroup,
      message: "Code Group updated successfully"
    }
  } catch (error) {
    console.error("Error updating code group:", error)
    return {
      success: false,
      error: "Failed to update code group"
    }
  }
}

// Code Group 삭제
export async function deleteCodeGroup(id: number) {
  try {
    // Code Group 정보 조회
    const codeGroup = await db
      .select({
        id: codeGroups.id,
        controlType: codeGroups.controlType,
        description: codeGroups.description
      })
      .from(codeGroups)
      .where(eq(codeGroups.id, id))
      .limit(1)

    if (codeGroup.length === 0) {
      return {
        success: false,
        error: "Code Group not found"
      }
    }

    // Control Type이 combobox인 경우 관련 Combo Box 옵션들도 삭제
    if (codeGroup[0].controlType === 'combobox') {
      // Combo Box 옵션들 삭제
      await db
        .delete(comboBoxSettings)
        .where(eq(comboBoxSettings.codeGroupId, id))
    }

    // Document Class가 연결된 경우 Document Class도 삭제
    await db
      .delete(documentClasses)
      .where(eq(documentClasses.codeGroupId, id))

    // Code Group 삭제
    await db
      .delete(codeGroups)
      .where(eq(codeGroups.id, id))

    revalidatePath("/evcp/docu-list-rule/code-groups")
    revalidatePath("/evcp/docu-list-rule/combo-box-settings")
    revalidatePath("/evcp/docu-list-rule/document-class")
    
    return {
      success: true,
      message: codeGroup[0].controlType === 'combobox' 
        ? `Code Group과 관련 Combo Box 옵션들이 삭제되었습니다.`
        : "Code Group이 삭제되었습니다."
    }
  } catch (error) {
    console.error("Error deleting code group:", error)
    return {
      success: false,
      error: "Failed to delete code group"
    }
  }
}

// Code Group 단일 조회
export async function getCodeGroupById(id: number) {
  try {
    const [codeGroup] = await db
      .select({
        id: codeGroups.id,
        groupId: codeGroups.groupId,
        description: codeGroups.description,
        codeFormat: codeGroups.codeFormat,
        expressions: codeGroups.expressions,
        controlType: codeGroups.controlType,
        isActive: codeGroups.isActive,
        createdAt: codeGroups.createdAt,
        updatedAt: codeGroups.updatedAt,
      })
      .from(codeGroups)
      .where(eq(codeGroups.id, id))
      .limit(1)

    return codeGroup || null
  } catch (error) {
    console.error("Error fetching code group by id:", error)
    return null
  }
}