/**
 * POP 컴포넌트 공통 타입 정의
 */

// ===== 스타일 관련 공통 타입 =====
// ===== 폰트 사이즈, 폰트 굵기, 텍스트 정렬, 이미지 맞춤 방식 정의 =====

export type FontSize = "xs" | "sm" | "base" | "lg" | "xl";
export type FontWeight = "normal" | "medium" | "bold";
export type TextAlign = "left" | "center" | "right" | "justify";
export type ObjectFit = "contain" | "cover" | "fill" | "none";

// ===== 라벨 매핑 =====

export const FONT_SIZE_LABELS: Record<FontSize, string> = {
  xs: "아주 작게",
  sm: "작게",
  base: "보통",
  lg: "크게",
  xl: "매우 크게",
};

export const FONT_WEIGHT_LABELS: Record<FontWeight, string> = {
  normal: "보통",
  medium: "중간",
  bold: "굵게",
};

export const TEXT_ALIGN_LABELS: Record<TextAlign, string> = {
  left: "왼쪽",
  center: "가운데",
  right: "오른쪽",
  justify: "양쪽 정렬",
};

export const OBJECT_FIT_LABELS: Record<ObjectFit, string> = {
  contain: "비율 유지",
  cover: "채우기",
  fill: "늘리기",
  none: "원본 크기",
};

// ===== Tailwind 클래스 매핑 =====

// 작게는 Tailwind 기본, 크게는 base(16px) 기준 2배씩: 12px → 14px → 16px → 32px → 64px
export const FONT_SIZE_CLASSES: Record<FontSize, string> = {
  xs: "text-xs",
  sm: "text-sm",
  base: "text-base",
  lg: "text-[32px]",
  xl: "text-[64px]",
};


export const FONT_WEIGHT_CLASSES: Record<FontWeight, string> = {
  normal: "font-normal",
  medium: "font-medium",
  bold: "font-bold",
};

export const TEXT_ALIGN_CLASSES: Record<TextAlign, string> = {
  left: "text-left",
  center: "text-center",
  right: "text-right",
  justify: "text-justify",
};

// ===== 상하 정렬 =====

export type VerticalAlign = "top" | "center" | "bottom";

export const VERTICAL_ALIGN_LABELS: Record<VerticalAlign, string> = {
  top: "위",
  center: "가운데",
  bottom: "아래",
};

export const VERTICAL_ALIGN_CLASSES: Record<VerticalAlign, string> = {
  top: "items-start",
  center: "items-center",
  bottom: "items-end",
};

// 좌우 정렬 (justify용 - flex 컨테이너에서 사용)
export const JUSTIFY_CLASSES: Record<string, string> = {
  left: "justify-start",
  center: "justify-center",
  right: "justify-end",
};

// =============================================
// Phase 0 공통 타입 (모든 POP 컴포넌트 공용)
// =============================================

// ----- 컬럼 바인딩: 컬럼별 읽기/쓰기 제어 -----

export type ColumnMode = "read" | "write" | "readwrite" | "hidden";

export interface ColumnBinding {
  columnName: string;
  sourceTable?: string;
  mode: ColumnMode;
  label?: string;
  defaultValue?: unknown;
}

// ----- 조인 설정: 테이블 간 관계 정의 -----

export type JoinType = "inner" | "left" | "right";

export interface JoinConfig {
  targetTable: string;
  joinType: JoinType;
  on: {
    sourceColumn: string;
    targetColumn: string;
  };
  columns?: string[];
}

// ----- 데이터 소스: 테이블 조회/집계 통합 설정 -----

export type AggregationType = "count" | "sum" | "avg" | "min" | "max";
export type FilterOperator =
  | "="
  | "!="
  | ">"
  | ">="
  | "<"
  | "<="
  | "like"
  | "in"
  | "between";

export interface DataSourceFilter {
  column: string;
  operator: FilterOperator;
  value: unknown; // between이면 [from, to]
}

export interface SortConfig {
  column: string;
  direction: "asc" | "desc";
}

export interface DataSourceConfig {
  tableName: string;
  columns?: ColumnBinding[];
  filters?: DataSourceFilter[];
  sort?: SortConfig[];
  aggregation?: {
    type: AggregationType;
    column: string;
    groupBy?: string[];
  };
  joins?: JoinConfig[];
  refreshInterval?: number; // 초 단위, 0이면 비활성
  limit?: number;
}

// ----- 액션 설정: 버튼/링크 클릭 시 동작 정의 -----

export interface PopActionConfig {
  type:
    | "navigate"
    | "modal"
    | "save"
    | "delete"
    | "api"
    | "event"
    | "refresh";
  // navigate
  targetScreenId?: string;
  params?: Record<string, string>;
  // modal
  modalScreenId?: string;
  modalTitle?: string;
  // save/delete
  targetTable?: string;
  confirmMessage?: string;
  // api
  apiEndpoint?: string;
  apiMethod?: "GET" | "POST" | "PUT" | "DELETE";
  // event
  eventName?: string;
  eventPayload?: Record<string, unknown>;
}

// =============================================
// pop-dashboard 전용 타입
// =============================================

// ----- 표시 모드 / 서브타입 -----

export type DashboardDisplayMode =
  | "arrows"
  | "auto-slide"
  | "scroll";
export type DashboardSubType = "kpi-card" | "chart" | "gauge" | "stat-card";
export type FormulaDisplayFormat = "value" | "fraction" | "percent" | "ratio";
export type ChartType = "bar" | "pie" | "line";
export type TrendPeriod = "daily" | "weekly" | "monthly";

// ----- 색상 구간 -----

export interface ColorRange {
  min: number;
  max: number;
  color: string; // hex 또는 Tailwind 색상
}

// ----- 수식(계산식) 설정 -----

export interface FormulaValue {
  id: string; // "A", "B" 등
  dataSource: DataSourceConfig;
  label: string; // "생산량", "총재고량"
}

export interface FormulaConfig {
  enabled: boolean;
  values: FormulaValue[];
  expression: string; // "A / B", "A + B", "A / B * 100"
  displayFormat: FormulaDisplayFormat;
}

// ----- 아이템 내 요소별 보이기/숨기기 -----

export interface ItemVisibility {
  showLabel: boolean;
  showValue: boolean;
  showUnit: boolean;
  showTrend: boolean;
  showSubLabel: boolean;
  showTarget: boolean;
}

// ----- 서브타입별 설정 -----

export interface KpiCardConfig {
  unit?: string; // "EA", "톤", "원"
  colorRanges?: ColorRange[];
  showTrend?: boolean;
  trendPeriod?: TrendPeriod;
}

export interface ChartItemConfig {
  chartType: ChartType;
  xAxisColumn?: string;
  yAxisColumn?: string;
  colors?: string[];
}

export interface GaugeConfig {
  min: number;
  max: number;
  target?: number; // 고정 목표값
  targetDataSource?: DataSourceConfig; // 동적 목표값
  colorRanges?: ColorRange[];
}

export interface StatCategory {
  label: string; // "대기", "진행", "완료"
  filter: DataSourceFilter;
  color?: string;
}

export interface StatCardConfig {
  categories: StatCategory[];
  showLink?: boolean;
  linkAction?: PopActionConfig;
}

// ----- 그리드 모드 셀 (엑셀형 분할/병합) -----

export interface DashboardCell {
  id: string;
  gridColumn: string; // CSS Grid 값: "1 / 3"
  gridRow: string; // CSS Grid 값: "1 / 2"
  itemId: string | null; // null이면 빈 셀
}

// ----- 대시보드 페이지(슬라이드) -----

/** 대시보드 한 페이지(슬라이드) - 독립적인 그리드 레이아웃 보유 */
export interface DashboardPage {
  id: string;
  label?: string; // 디자이너에서 표시할 라벨 (예: "페이지 1")
  gridColumns: number; // 이 페이지의 열 수
  gridRows: number; // 이 페이지의 행 수
  gridCells: DashboardCell[]; // 이 페이지의 셀 배치 (각 셀에 itemId 지정)
}

// ----- 대시보드 아이템 스타일 설정 -----

export interface ItemStyleConfig {
  /** 라벨 텍스트 정렬 (기본: center) */
  labelAlign?: TextAlign;
}

// ----- 대시보드 아이템 -----

export interface DashboardItem {
  id: string;
  label: string; // pop-system 보이기/숨기기용
  visible: boolean;
  subType: DashboardSubType;
  dataSource: DataSourceConfig;

  // 요소별 보이기/숨기기
  visibility: ItemVisibility;

  // 계산식 (선택사항)
  formula?: FormulaConfig;

  // 서브타입별 설정 (subType에 따라 하나만 사용)
  kpiConfig?: KpiCardConfig;
  chartConfig?: ChartItemConfig;
  gaugeConfig?: GaugeConfig;
  statConfig?: StatCardConfig;

  /** 스타일 설정 (정렬, 글자 크기 3그룹) */
  itemStyle?: ItemStyleConfig;
}

// ----- 대시보드 전체 설정 -----

export interface PopDashboardConfig {
  items: DashboardItem[];
  pages?: DashboardPage[]; // 페이지 배열 (각 페이지가 독립 그리드 레이아웃)
  displayMode: DashboardDisplayMode; // 페이지 간 전환 방식

  // 모드별 설정
  autoSlideInterval?: number; // 초 (기본 5)
  autoSlideResumeDelay?: number; // 터치 후 재개 대기 초 (기본 3)

  // 공통 스타일
  showIndicator?: boolean; // 페이지 인디케이터
  gap?: number; // 아이템 간 간격 px
  backgroundColor?: string;

  // 데이터 소스 (아이템 공통)
  dataSource?: DataSourceConfig;
}


// ----- 조인 설정 -----

export interface CardColumnJoin {
  targetTable: string;
  joinType: "LEFT" | "INNER" | "RIGHT";
  sourceColumn: string; // 메인 테이블 컬럼
  targetColumn: string; // 조인 테이블 컬럼
  selectedTargetColumns?: string[]; // 가져올 대상 테이블 컬럼 목록
}

// ----- 필터 설정 -----

export interface CardColumnFilter {
  column: string;
  operator: FilterOperator;
  value: string;
}

// ----- 본문 필드 바인딩 (라벨-값 쌍) -----

export type FieldValueType = "column" | "formula";
export type FormulaOperator = "+" | "-" | "*" | "/";
export type FormulaRightType = "column" | "input";

export interface CardFieldBinding {
  id: string;
  label: string;
  valueType: FieldValueType;
  columnName?: string;         // valueType === "column"일 때 DB 컬럼명
  // 구조화된 수식 (클릭형 빌더)
  formulaLeft?: string;        // 왼쪽: DB 컬럼명
  formulaOperator?: FormulaOperator;
  formulaRightType?: FormulaRightType; // "column" 또는 "input"($input)
  formulaRight?: string;       // rightType === "column"일 때 DB 컬럼명
  /** @deprecated 구조화 수식 필드 사용, 하위 호환용 */
  formula?: string;
  unit?: string;
  textColor?: string;
}

// ----- 카드 헤더 설정 (코드 + 제목) -----

export interface CardHeaderConfig {
  codeField?: string; // 코드로 표시할 컬럼 선택
  titleField?: string; // 제목으로 표시할 컬럼 선택
}

// ----- 카드 이미지 설정 -----

// 기본 이미지 URL (박스 아이콘)
export const DEFAULT_CARD_IMAGE =
  "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%239ca3af' stroke-width='1.5'%3E%3Cpath d='M20 7l-8-4-8 4m16 0l-8 4m8-4v10l-8 4m0-10L4 7m8 4v10M4 7v10l8 4'/%3E%3C/svg%3E";

export interface CardImageConfig {
  enabled: boolean;
  imageColumn?: string; // 이미지 URL 컬럼 (선택)
  defaultImage: string; // 기본 이미지 (자동 설정, 필수)
}

// ----- 카드 본문 설정 -----

export interface CardBodyConfig {
  fields: CardFieldBinding[]; // 라벨-값 쌍 목록
}

// ----- 카드 템플릿 (헤더 + 이미지 + 본문) -----

export interface CardTemplateConfig {
  header: CardHeaderConfig;
  image: CardImageConfig;
  body: CardBodyConfig;
}

// ----- 데이터 소스 (테이블 단위) -----

export interface CardSortConfig {
  column: string;
  direction: "asc" | "desc";
}

export interface CardListDataSource {
  tableName: string;
  joins?: CardColumnJoin[];
  filters?: CardColumnFilter[];
  sort?: CardSortConfig[];
  limit?: { mode: "all" | "limited"; count?: number };
}

// ----- 카드 크기 -----

export type CardSize = "small" | "medium" | "large";

export const CARD_SIZE_LABELS: Record<CardSize, string> = {
  small: "작게",
  medium: "보통",
  large: "크게",
};

// ----- 카드 스크롤 방향 -----

export type CardScrollDirection = "horizontal" | "vertical";

export const CARD_SCROLL_DIRECTION_LABELS: Record<CardScrollDirection, string> = {
  horizontal: "가로 스크롤",
  vertical: "세로 스크롤",
};

// ----- 카드 내 입력 필드 설정 -----

export interface CardInputFieldConfig {
  enabled: boolean;
  unit?: string;               // 단위 (예: "EA")
  limitColumn?: string;        // 제한 기준 컬럼 (해당 행의 이 컬럼 값이 최대값)
  saveTable?: string;          // 저장 대상 테이블
  saveColumn?: string;         // 저장 대상 컬럼
  /** @deprecated limitColumn 사용 */
  maxColumn?: string;
  /** @deprecated 미사용, 하위 호환용 */
  label?: string;
  /** @deprecated packageConfig로 이동, 하위 호환용 */
  showPackageUnit?: boolean;
}

// ----- 포장등록 설정 -----

export interface CustomPackageUnit {
  id: string;
  label: string;         // 표시명 (예: "파렛트")
}

export interface CardPackageConfig {
  enabled: boolean;                      // 포장등록 기능 ON/OFF
  enabledUnits?: string[];               // 활성화된 기본 단위 (예: ["box", "bag"]), undefined면 전체 표시
  customUnits?: CustomPackageUnit[];     // 디자이너가 추가한 커스텀 단위
  showSummaryMessage?: boolean;          // 계산 결과 안내 메시지 표시 (기본 true)
}

// ----- 포장 내역 (2단계 계산 결과) -----

export interface PackageEntry {
  unitId: string;          // 포장 단위 ID (예: "box")
  unitLabel: string;       // 포장 단위 표시명 (예: "박스")
  packageCount: number;    // 포장 수량 (예: 3)
  quantityPerUnit: number; // 개당 수량 (예: 80)
  totalQuantity: number;   // 합계 = packageCount * quantityPerUnit
}

// ----- 담기 버튼 데이터 구조 (로컬 상태용) -----

export interface CartItem {
  row: Record<string, unknown>; // 카드 원본 행 데이터
  quantity: number; // 입력 수량
  packageUnit?: string; // 포장 단위 (box/bag/pack/bundle/roll/barrel)
  packageEntries?: PackageEntry[]; // 포장 내역 (2단계 계산 시)
}

// ----- 장바구니 DB 연동용 확장 타입 -----

export type CartSyncStatus = "clean" | "dirty" | "saving";
export type CartItemOrigin = "db" | "local";
export type CartItemStatus = "in_cart" | "confirmed" | "cancelled";

export interface CartItemWithId extends CartItem {
  cartId?: string;                        // DB id (UUID, 저장 후 할당)
  sourceTable: string;                    // 원본 테이블명
  rowKey: string;                         // 원본 행 식별키 (keyColumn 값, 기본 id)
  status: CartItemStatus;
  _origin: CartItemOrigin;                // DB에서 로드 vs 로컬에서 추가
  memo?: string;
}


// ----- 담기 버튼 액션 설정 (pop-icon 스타일 + 장바구니 연동) -----


export type CartSaveMode = "cart" | "direct";

export interface CardCartActionConfig {
  saveMode: CartSaveMode;           // "cart": 장바구니 임시저장, "direct": 대상 테이블 직접 저장
  keyColumn?: string;               // 행 식별 키 컬럼 (기본: "id")
  label?: string;                   // 담기 라벨 (기본: "담기")
  cancelLabel?: string;             // 취소 라벨 (기본: "취소")
  // 하위 호환: 이전 dataFields (사용하지 않지만 기존 데이터 보호)
  dataFields?: { sourceField: string; targetField?: string; label?: string }[];
  // 하위 호환: 기존 필드 (사용하지 않지만 기존 데이터 보호)
  navigateMode?: "none" | "screen";
  targetScreenId?: string;
  iconType?: "lucide" | "emoji";
  iconValue?: string;
}

// ----- pop-card-list 전체 설정 -----

// ----- 카드 프리셋별 고정 규격 -----
// 각 프리셋은 카드 내용이 잘리지 않도록 계산된 고정 크기
// 구성: 헤더(코드+제목) + 본문(이미지+필드 3개) + 입력/계산 필드 + 패딩
export interface CardPresetSpec {
  height: number;    // 카드 고정 높이 (px)
  imageSize: number; // 이미지 크기 (px)
  padding: number;   // 내부 여백 (px)
  gap: number;       // 요소 간격 (px)
  headerPadY: number; // 헤더 상하 패딩 (px)
  headerPadX: number; // 헤더 좌우 패딩 (px)
  codeText: number;  // 코드 폰트 크기 (px)
  titleText: number; // 제목 폰트 크기 (px)
  bodyText: number;  // 본문 폰트 크기 (px)
}

export const CARD_PRESET_SPECS: Record<CardSize, CardPresetSpec> = {
  // 작게: 컴팩트 - 헤더(20) + 본문(이미지36+필드3x14=42) + 패딩(6*3) = ~80px
  small: {
    height: 88,
    imageSize: 36,
    padding: 6,
    gap: 4,
    headerPadY: 3,
    headerPadX: 6,
    codeText: 9,
    titleText: 11,
    bodyText: 10,
  },
  // 보통: 기본 - 헤더(26) + 본문(이미지48+필드3x16=48) + 패딩(8*3) = ~122px
  medium: {
    height: 120,
    imageSize: 48,
    padding: 8,
    gap: 6,
    headerPadY: 4,
    headerPadX: 8,
    codeText: 10,
    titleText: 13,
    bodyText: 11,
  },
  // 크게: 여유 - 헤더(32) + 본문(이미지64+필드3x18=54) + 패딩(10*3) = ~156px
  large: {
    height: 160,
    imageSize: 64,
    padding: 10,
    gap: 8,
    headerPadY: 6,
    headerPadX: 10,
    codeText: 11,
    titleText: 15,
    bodyText: 12,
  },
};

// ----- 반응형 표시 모드 -----

export type ResponsiveDisplayMode = "required" | "shrink" | "hidden";

export const RESPONSIVE_DISPLAY_LABELS: Record<ResponsiveDisplayMode, string> = {
  required: "필수",
  shrink: "축소",
  hidden: "숨김",
};

export interface CardResponsiveConfig {
  code?: ResponsiveDisplayMode;
  title?: ResponsiveDisplayMode;
  image?: ResponsiveDisplayMode;
  fields?: Record<string, ResponsiveDisplayMode>;
}

// ----- 장바구니 목록 모드 설정 -----

export interface CartListModeConfig {
  enabled: boolean;
  sourceScreenId?: number;
  sourceComponentId?: string;
  statusFilter?: string;
}

// ----- 데이터 수집 패턴 (pop-button ↔ 컴포넌트 간 요청-응답) -----

export interface CollectDataRequest {
  requestId: string;
  action: string;
}

export interface CollectedDataResponse {
  requestId: string;
  componentId: string;
  componentType: string;
  data: {
    items?: Record<string, unknown>[];
    values?: Record<string, unknown>;
  };
  mapping?: SaveMapping | null;
}

export interface SaveMapping {
  targetTable: string;
  columnMapping: Record<string, string>;
  autoGenMappings?: Array<{
    numberingRuleId: string;
    targetColumn: string;
    showResultModal?: boolean;
  }>;
  hiddenMappings?: Array<{
    valueSource: "json_extract" | "db_column" | "static";
    targetColumn: string;
    staticValue?: string;
    sourceJsonColumn?: string;
    sourceJsonKey?: string;
    sourceDbColumn?: string;
  }>;
}

export interface StatusChangeRule {
  targetTable: string;
  targetColumn: string;
  lookupMode?: "auto" | "manual";
  manualItemField?: string;
  manualPkColumn?: string;
  valueType: "fixed" | "conditional";
  fixedValue?: string;
  conditionalValue?: ConditionalValue;
}

export interface ConditionalValue {
  conditions: StatusCondition[];
  defaultValue?: string;
}

export interface StatusCondition {
  whenColumn: string;
  operator: "=" | "!=" | ">" | "<" | ">=" | "<=";
  whenValue: string;
  thenValue: string;
}

export interface ExecuteActionPayload {
  inserts: {
    table: string;
    records: Record<string, unknown>[];
  }[];
  statusChanges: {
    table: string;
    column: string;
    value: string;
    where: Record<string, unknown>;
  }[];
}

// ----- 저장 매핑 (장바구니 -> 대상 테이블) -----

export interface CardListSaveMappingEntry {
  sourceField: string;
  targetColumn: string;
}

export interface CardListSaveMapping {
  targetTable: string;
  mappings: CardListSaveMappingEntry[];
}

// ----- pop-card-list 전체 설정 -----

export interface PopCardListConfig {
  dataSource: CardListDataSource;
  cardTemplate: CardTemplateConfig;
  scrollDirection: CardScrollDirection;
  cardsPerRow?: number; // deprecated, gridColumns 사용
  cardSize: CardSize;

  gridColumns?: number;
  gridRows?: number;

  responsiveDisplay?: CardResponsiveConfig;

  inputField?: CardInputFieldConfig;
  packageConfig?: CardPackageConfig;
  cartAction?: CardCartActionConfig;

  cartListMode?: CartListModeConfig;
  saveMapping?: CardListSaveMapping;

  requireFilter?: boolean;
  requireFilterMessage?: string;
}

// =============================================
// pop-card-list-v2 전용 타입 (슬롯 기반 카드)
// =============================================

import type { ButtonMainAction, ButtonVariant, ConfirmConfig } from "./pop-button";

export type CardCellType =
  | "text"
  | "field"
  | "image"
  | "badge"
  | "button"
  | "number-input"
  | "package-summary"
  | "status-badge"
  | "timeline"
  | "action-buttons"
  | "footer-status"
  | "process-qty-summary"
  | "mes-process-card";

// timeline 셀에서 사용하는 하위 단계 데이터
export interface TimelineProcessStep {
  seqNo: number;
  processName: string;
  status: string;                              // DB 원본 값 (또는 derivedFrom에 의해 변환된 값)
  semantic?: "pending" | "active" | "done";    // 시각적 의미 (렌더러 색상 결정)
  isCurrent: boolean;
  processId?: string | number;                 // 공정 테이블 레코드 PK (접수 등 UPDATE 대상 특정용)
  rawData?: Record<string, unknown>;           // 하위 테이블 원본 행 (하위 필터 매칭용)
  // 수량 필드 (process-flow-summary 셀용)
  inputQty?: number;                           // 접수량
  totalProductionQty?: number;                 // 총생산량
  goodQty?: number;                            // 양품
  defectQty?: number;                          // 불량
  yieldRate?: number;                          // 수율 (양품/총생산*100)
}

// timeline/status-badge/action-buttons가 참조하는 하위 테이블 설정
export interface TimelineDataSource {
  processTable: string;       // 하위 데이터 테이블명 (예: work_order_process)
  foreignKey: string;         // 메인 테이블 id와 매칭되는 FK 컬럼 (예: wo_id)
  seqColumn: string;          // 순서 컬럼 (예: seq_no)
  nameColumn: string;         // 표시명 컬럼 (예: process_name)
  statusColumn: string;       // 상태 컬럼 (예: status)
  // 상태 값 매핑: DB값 → 시맨틱 (동적 배열, 순서대로 표시)
  // 레거시 호환: 기존 { waiting, accepted, inProgress, completed } 객체도 런타임에서 자동 변환
  statusMappings?: StatusValueMapping[];
}

export type TimelineStatusSemantic = "pending" | "active" | "done";

export interface StatusValueMapping {
  dbValue: string;                    // DB에 저장된 실제 값 (또는 파생 상태의 식별값)
  label: string;                      // 화면에 보이는 이름
  semantic: TimelineStatusSemantic;   // 타임라인 색상 결정 (pending=회색, active=파랑, done=초록)
  isDerived?: boolean;               // true면 DB에 없는 자동 판별 상태 (이전 공정 완료 시 변환)
}

export interface CardCellDefinitionV2 {
  id: string;
  row: number;
  col: number;
  rowSpan: number;
  colSpan: number;
  type: CardCellType;

  // 공통
  columnName?: string;
  label?: string;
  labelPosition?: "top" | "left";
  fontSize?: "xs" | "sm" | "md" | "lg";
  fontWeight?: "normal" | "medium" | "bold";
  textColor?: string;
  align?: "left" | "center" | "right";
  verticalAlign?: "top" | "middle" | "bottom";

  // field 타입 전용 (CardFieldBinding 흡수)
  valueType?: "column" | "formula";
  formulaLeft?: string;
  formulaOperator?: "+" | "-" | "*" | "/";
  formulaRight?: string;
  formulaRightType?: "input" | "column";
  unit?: string;

  // image 타입 전용
  defaultImage?: string;

  // button 타입 전용
  buttonAction?: ButtonMainAction;
  buttonVariant?: ButtonVariant;
  buttonConfirm?: ConfirmConfig;

  // number-input 타입 전용
  inputUnit?: string;
  limitColumn?: string;
  autoInitMax?: boolean;

  // status-badge 타입 전용
  statusColumn?: string;
  statusMap?: Array<{ value: string; label: string; color: string }>;

  // timeline 타입 전용: 공정 데이터 소스 설정
  timelineSource?: TimelineDataSource;
  processColumn?: string;
  processStatusColumn?: string;
  currentHighlight?: boolean;
  visibleCount?: number;
  timelinePriority?: "before" | "after";
  showDetailModal?: boolean;

  // action-buttons 타입 전용 (신규: 버튼 중심 구조)
  actionButtons?: ActionButtonDef[];
  // action-buttons 타입 전용 (구: 조건 중심 구조, 하위호환)
  actionRules?: Array<{
    whenStatus: string;
    buttons: Array<ActionButtonConfig>;
  }>;

  // footer-status 타입 전용
  footerLabel?: string;
  footerStatusColumn?: string;
  footerStatusMap?: Array<{ value: string; label: string; color: string }>;
  showTopBorder?: boolean;

  // process-qty-summary 타입 전용 - 공정별 수량 흐름 요약
  qtyDisplayMode?: "current" | "flow";  // current: 현재 공정만, flow: 전체 공정 흐름
}

export interface ActionButtonUpdate {
  column: string;
  value?: string;
  valueType: "static" | "currentUser" | "currentTime" | "columnRef" | "userInput";
  operationType?: "assign" | "add" | "subtract";
}

// 액션 버튼 클릭 시 동작 모드
export type ActionButtonClickMode = "status-change" | "modal-open" | "select-mode";

// 액션 버튼 개별 설정
export interface ActionButtonConfig {
  label: string;
  variant: ButtonVariant;
  taskPreset: string;
  confirm?: ConfirmConfig;
  targetTable?: string;
  confirmMessage?: string;
  allowMultiSelect?: boolean;
  updates?: ActionButtonUpdate[];
  clickMode?: ActionButtonClickMode;
  selectModeConfig?: SelectModeConfig;
}

// 선택 모드 설정
export interface SelectModeConfig {
  filterStatus?: string;
  buttons: Array<SelectModeButtonConfig>;
}

// 선택 모드 하단 버튼 설정
export interface SelectModeButtonConfig {
  label: string;
  variant: ButtonVariant;
  clickMode: "status-change" | "modal-open" | "cancel-select" | "quantity-input";
  targetTable?: string;
  updates?: ActionButtonUpdate[];
  confirmMessage?: string;
  modalScreenId?: string;
  quantityInput?: QuantityInputConfig;
}

// ===== 버튼 중심 구조 (신규) =====

export interface ActionButtonShowCondition {
  type: "timeline-status" | "column-value" | "always" | "owner-match";
  value?: string;
  column?: string;
  unmatchBehavior?: "hidden" | "disabled";
}

export interface ActionButtonClickAction {
  type: "immediate" | "select-mode" | "modal-open" | "quantity-input";
  targetTable?: string;
  updates?: ActionButtonUpdate[];
  confirmMessage?: string;
  selectModeButtons?: SelectModeButtonConfig[];
  modalScreenId?: string;
  joinConfig?: {
    sourceColumn: string;
    targetColumn: string;
  };
  quantityInput?: QuantityInputConfig;
  preCondition?: ActionPreCondition;
}

export interface QuantityInputConfig {
  maxColumn?: string;
  currentColumn?: string;
  unit?: string;
  enablePackage?: boolean;
}

export interface ActionPreCondition {
  column: string;
  expectedValue: string;
  failMessage?: string;
}

export interface ActionButtonDef {
  label: string;
  variant: ButtonVariant;
  showCondition?: ActionButtonShowCondition;
  /** 단일 액션 (하위호환) 또는 다중 액션 체이닝 */
  clickAction: ActionButtonClickAction;
  clickActions?: ActionButtonClickAction[];
}

export interface CardGridConfigV2 {
  rows: number;
  cols: number;
  colWidths: string[];
  rowHeights?: string[];
  gap: number;
  showCellBorder: boolean;
  cells: CardCellDefinitionV2[];
}

// ----- V2 카드 선택 동작 -----

export type V2CardClickAction = "none" | "publish" | "navigate" | "modal-open" | "built-in-work-detail";

export interface V2CardClickModalConfig {
  screenId: string;
  modalTitle?: string;
  condition?: {
    type: "timeline-status" | "column-value" | "always";
    value?: string;
    column?: string;
  };
}

// ----- V2 오버플로우 설정 -----

export interface V2OverflowConfig {
  mode: "loadMore" | "pagination";
  visibleCount: number;
  loadMoreCount?: number;
  pageSize?: number;
}

// ----- pop-card-list-v2 전체 설정 -----

export interface PopCardListV2Config {
  dataSource: CardListDataSource;
  cardGrid: CardGridConfigV2;
  selectedColumns?: string[];
  gridColumns?: number;
  gridRows?: number;
  scrollDirection?: CardScrollDirection;
  /** @deprecated 열 수(gridColumns)로 카드 크기 결정. 하위 호환용 */
  cardSize?: CardSize;
  cardGap?: number;
  overflow?: V2OverflowConfig;
  cardClickAction?: V2CardClickAction;
  cardClickModalConfig?: V2CardClickModalConfig;
  /** 연결된 필터 값이 전달되기 전까지 데이터 비표시 */
  hideUntilFiltered?: boolean;
  hideUntilFilteredMessage?: string;
  responsiveDisplay?: CardResponsiveConfig;
  inputField?: CardInputFieldConfig;
  packageConfig?: CardPackageConfig;
  saveMapping?: CardListSaveMapping;
  ownerSortColumn?: string;
  ownerFilterMode?: "priority" | "only";
  workDetailConfig?: PopWorkDetailConfig;
  showStatusTabs?: boolean;
}

/** 카드 컴포넌트가 하위 필터 적용 시 주입하는 가상 컬럼 키 */
export const VIRTUAL_SUB_STATUS = "__subStatus__" as const;
export const VIRTUAL_SUB_SEMANTIC = "__subSemantic__" as const;
export const VIRTUAL_SUB_PROCESS = "__subProcessName__" as const;
export const VIRTUAL_SUB_SEQ = "__subSeqNo__" as const;


// =============================================
// pop-work-detail 전용 타입
// =============================================

export interface WorkDetailInfoBarField {
  label: string;
  column: string;
}

export interface WorkDetailInfoBarConfig {
  enabled: boolean;
  fields: WorkDetailInfoBarField[];
}

export interface WorkDetailStepControl {
  requireStartBeforeInput: boolean;
  autoAdvance: boolean;
}

export interface WorkDetailNavigationConfig {
  showPrevNext: boolean;
  showCompleteButton: boolean;
}

export type ResultSectionType =
  | "total-qty"
  | "good-defect"
  | "defect-types"
  | "note"
  | "box-packing"
  | "label-print"
  | "photo"
  | "document"
  | "material-input"
  | "barcode-scan"
  | "plc-data";

export interface ResultSectionConfig {
  id: string;
  type: ResultSectionType;
  enabled: boolean;
  showCondition?: { type: "always" | "last-process" };
}

export interface PopWorkDetailConfig {
  showTimer: boolean;
  /** @deprecated result-input 타입으로 대체 */
  showQuantityInput: boolean;
  /** 표시 모드: list(기존 리스트), step(한 항목씩 진행) */
  displayMode: "list" | "step";
  phaseLabels: Record<string, string>;
  infoBar: WorkDetailInfoBarConfig;
  stepControl: WorkDetailStepControl;
  navigation: WorkDetailNavigationConfig;
  resultSections?: ResultSectionConfig[];
}
