// 테넌트(회사) 설정 Config
// 멀티테넌시 지원을 위한 회사별 설정 관리 시스템
// 문서양식, 채번규칙, 결재라인 등 회사별 커스터마이징 지원

/**
 * 테넌트 설정 스키마
 *
 * 3-레이어 아키텍처:
 * 1. 시스템 기본값 (systemDefaults) - 모든 테넌트 공통
 * 2. 테넌트 설정 (tenants) - 회사별 오버라이드
 * 3. 문서 인스턴스 - 개별 문서 생성 시 적용
 *
 * 우선순위: 문서 인스턴스 > 테넌트 설정 > 시스템 기본값
 */

const tenantConfig = {
  id: 'tenant-config',
  title: '테넌트(회사) 관리',
  description: '멀티테넌시 지원을 위한 회사별 설정 관리',
  version: '1.0.0',

  // ============================================================
  // 1. 시스템 기본값 (모든 테넌트 공통)
  // ============================================================
  systemDefaults: {
    // 문서 기본 설정
    document: {
      paperSize: 'A4',
      orientation: 'portrait',
      margins: { top: 15, right: 15, bottom: 15, left: 15 },
      fontSize: 11,
      fontFamily: 'Malgun Gothic, sans-serif',
      lineHeight: 1.4,
      language: 'ko-KR',
      currency: 'KRW',
      currencySymbol: '₩',
      dateFormat: 'YYYY-MM-DD',
      numberFormat: '#,###',
    },
    // 결재라인 기본값
    approval: {
      useApproval: true,
      levels: ['작성', '검토', '승인'],
      showSignature: true,
      showDate: true,
      signatureType: 'stamp', // stamp | handwrite | digital
    },
    // 로고 기본값
    logo: {
      maxWidth: 120,
      maxHeight: 60,
      position: 'left',
      showCompanyName: true,
    },
    // 채번 기본 설정
    numbering: {
      resetCycle: 'daily', // daily | monthly | yearly | never
      sequenceDigits: 2,
      includeDateInNo: true,
      dateFormat: 'YYMMDD',
    },
  },

  // ============================================================
  // 2. 테넌트(회사) 목록
  // ============================================================
  tenants: {
    // 테넌트 1: KD경동기업 (기본 테넌트)
    'KD001': {
      id: 'KD001',
      code: 'KD',
      name: 'KD경동기업',
      fullName: '주식회사 KD경동기업',
      englishName: 'KD KYUNGDONG COMPANY',
      isDefault: true,
      isActive: true,
      createdAt: '2024-01-01',

      // 회사 기본 정보
      companyInfo: {
        businessNo: '123-45-67890',
        ceo: '홍길동',
        businessType: '제조업',
        businessItem: '방화셔터, 방화문, 자동문',
        address: '경기도 화성시 정남면 시청로 1234',
        phone: '031-123-4567',
        fax: '031-123-4568',
        email: 'info@kdcompany.co.kr',
        website: 'www.kdcompany.co.kr',
      },

      // 로고 설정
      logo: {
        primary: '/assets/logos/kd-logo.png',
        secondary: '/assets/logos/kd-logo-white.png',
        icon: '/assets/logos/kd-icon.png',
        // 텍스트 기반 로고 (이미지 없을 경우)
        textLogo: {
          main: 'KD',
          sub: '경동기업',
          subSub: 'KYUNGDONG COMPANY',
          style: 'blue-box', // blue-box | simple | badge
        },
      },

      // 인감/도장 설정
      seals: {
        companySeal: '/assets/seals/kd-company-seal.png',
        ceoSeal: '/assets/seals/kd-ceo-seal.png',
        useSeal: true,
      },

      // 결재라인 설정
      approvalLines: {
        // 기본 결재라인
        default: {
          id: 'default',
          name: '기본 결재',
          levels: [
            { id: 'write', label: '작성', role: '담당자', width: 60 },
            { id: 'review', label: '검토', role: '팀장', width: 60 },
            { id: 'approve', label: '승인', role: '부장', width: 60 },
          ],
        },
        // 작업일지용 결재라인
        worklog: {
          id: 'worklog',
          name: '작업일지 결재',
          levels: [
            { id: 'write', label: '작성', role: '판매/전진', width: 60 },
            { id: 'review', label: '검토', role: '생산', width: 60 },
            { id: 'approve', label: '승인', role: '품질', width: 60, highlight: true, highlightColor: '#00FFFF' },
          ],
          showRole: true,
          showDate: true,
        },
        // 견적서/수주용 결재라인
        sales: {
          id: 'sales',
          name: '영업문서 결재',
          levels: [
            { id: 'write', label: '작성', role: '영업담당', width: 60 },
            { id: 'review', label: '검토', role: '영업팀장', width: 60 },
            { id: 'approve', label: '승인', role: '이사', width: 60 },
          ],
        },
        // 품질검사용 결재라인
        quality: {
          id: 'quality',
          name: '품질문서 결재',
          levels: [
            { id: 'inspect', label: '검사', role: '검사원', width: 60 },
            { id: 'review', label: '검토', role: '품질팀장', width: 60 },
            { id: 'approve', label: '승인', role: '품질관리자', width: 60 },
          ],
        },
      },

      // 채번 규칙 오버라이드
      numberingRules: {
        // 견적서
        'QT': {
          prefix: 'QT',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '견적서',
        },
        // 수주확인서
        'SO': {
          prefix: 'SO',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '수주확인서',
        },
        // 작업지시서 (공정별)
        'WO-SCR': {
          prefix: 'WO-SCR',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '작업지시서(스크린)',
        },
        'WO-SLT': {
          prefix: 'WO-SLT',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '작업지시서(슬랫)',
        },
        'WO-FLD': {
          prefix: 'WO-FLD',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '작업지시서(절곡)',
        },
        // 작업일지 (공정별)
        'WL-SCR': {
          prefix: 'WL-SCR',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '작업일지(스크린)',
        },
        'WL-FLD': {
          prefix: 'WL-FLD',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '작업일지(절곡)',
        },
        'WL-SLT': {
          prefix: 'WL-SLT',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '작업일지(슬랫)',
        },
        // 검사서류
        'IQC': {
          prefix: 'IQC',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '수입검사',
        },
        'PQC': {
          prefix: 'PQC',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '공정검사',
        },
        'FQC': {
          prefix: 'FQC',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '최종검사',
        },
        // 부적합
        'NCR': {
          prefix: 'NCR',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '부적합보고서',
        },
        // 출하/발주
        'SL': {
          prefix: 'SL',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '출하지시서',
        },
        'PO': {
          prefix: 'PO',
          pattern: '{PREFIX}-{YYMMDD}-{##}',
          resetCycle: 'daily',
          description: '발주서',
        },
        // LOT번호
        'LOT': {
          prefix: 'LOT',
          pattern: '{PREFIX}-{YYYYMMDD}-{###}',
          resetCycle: 'daily',
          description: 'LOT번호',
        },
      },

      // 문서별 스타일 오버라이드
      documentStyles: {
        // 작업일지 스타일
        worklog: {
          header: {
            logoStyle: 'blue-box',
            titleLetterSpacing: '1em',
            subtitleBg: '#FFFF00',
          },
          approval: {
            footerHighlightBg: '#00FFFF',
          },
        },
        // 견적서 스타일
        quote: {
          header: {
            titleLetterSpacing: '0.5em',
          },
          footer: {
            showBankInfo: true,
            bankInfo: {
              bank: '국민은행',
              account: '123-456-789012',
              holder: '주식회사 KD경동기업',
            },
          },
        },
      },

      // 테넌트별 커스텀 블록
      customBlocks: [],
    },

    // 테넌트 2: 샘플 회사 (신규 테넌트 추가 예시)
    'SAMPLE001': {
      id: 'SAMPLE001',
      code: 'SPL',
      name: '샘플기업',
      fullName: '주식회사 샘플기업',
      englishName: 'SAMPLE COMPANY',
      isDefault: false,
      isActive: false, // 비활성화 상태
      createdAt: '2024-06-01',

      companyInfo: {
        businessNo: '987-65-43210',
        ceo: '김철수',
        businessType: '제조업',
        businessItem: '산업용 도어',
        address: '서울특별시 강남구 테헤란로 123',
        phone: '02-123-4567',
        fax: '02-123-4568',
        email: 'info@sample.co.kr',
        website: 'www.sample.co.kr',
      },

      logo: {
        primary: '/assets/logos/sample-logo.png',
        textLogo: {
          main: 'SPL',
          sub: '샘플기업',
          style: 'simple',
        },
      },

      seals: {
        companySeal: '/assets/seals/sample-seal.png',
        useSeal: true,
      },

      approvalLines: {
        default: {
          id: 'default',
          name: '기본 결재',
          levels: [
            { id: 'write', label: '기안', role: '담당', width: 60 },
            { id: 'approve', label: '결재', role: '대표', width: 60 },
          ],
        },
      },

      // 채번 규칙 (이 테넌트는 월간 리셋 사용)
      numberingRules: {
        'QT': {
          prefix: 'SPL-Q',
          pattern: '{PREFIX}{YYMM}-{###}',
          resetCycle: 'monthly',
          description: '견적서',
        },
        'SO': {
          prefix: 'SPL-O',
          pattern: '{PREFIX}{YYMM}-{###}',
          resetCycle: 'monthly',
          description: '수주확인서',
        },
      },

      documentStyles: {},
      customBlocks: [],
    },
  },

  // ============================================================
  // 3. 테넌트 스키마 정의 (신규 테넌트 생성 시 참조)
  // ============================================================
  tenantSchema: {
    required: ['id', 'code', 'name', 'companyInfo'],
    properties: {
      id: { type: 'string', description: '테넌트 고유 ID', pattern: '^[A-Z0-9]+$' },
      code: { type: 'string', description: '테넌트 코드 (2-4자)', minLength: 2, maxLength: 4 },
      name: { type: 'string', description: '회사명' },
      fullName: { type: 'string', description: '회사 정식명칭' },
      englishName: { type: 'string', description: '영문 회사명' },
      isDefault: { type: 'boolean', description: '기본 테넌트 여부', default: false },
      isActive: { type: 'boolean', description: '활성화 상태', default: true },
      companyInfo: {
        type: 'object',
        required: ['businessNo', 'ceo', 'address'],
        properties: {
          businessNo: { type: 'string', description: '사업자등록번호' },
          ceo: { type: 'string', description: '대표자' },
          businessType: { type: 'string', description: '업태' },
          businessItem: { type: 'string', description: '종목' },
          address: { type: 'string', description: '사업장주소' },
          phone: { type: 'string', description: '전화번호' },
          fax: { type: 'string', description: '팩스번호' },
          email: { type: 'string', description: '이메일', format: 'email' },
          website: { type: 'string', description: '웹사이트' },
        },
      },
      logo: {
        type: 'object',
        properties: {
          primary: { type: 'string', description: '기본 로고 경로' },
          secondary: { type: 'string', description: '보조 로고 경로' },
          icon: { type: 'string', description: '아이콘 로고 경로' },
          textLogo: {
            type: 'object',
            properties: {
              main: { type: 'string', description: '메인 텍스트' },
              sub: { type: 'string', description: '서브 텍스트' },
              subSub: { type: 'string', description: '영문 텍스트' },
              style: { type: 'string', enum: ['blue-box', 'simple', 'badge'] },
            },
          },
        },
      },
      seals: {
        type: 'object',
        properties: {
          companySeal: { type: 'string', description: '법인인감 이미지 경로' },
          ceoSeal: { type: 'string', description: '대표이사 인감 이미지 경로' },
          useSeal: { type: 'boolean', description: '인감 사용 여부' },
        },
      },
      approvalLines: {
        type: 'object',
        description: '결재라인 설정',
        additionalProperties: {
          type: 'object',
          properties: {
            id: { type: 'string' },
            name: { type: 'string' },
            levels: { type: 'array', items: { type: 'object' } },
          },
        },
      },
      numberingRules: {
        type: 'object',
        description: '채번 규칙 오버라이드',
        additionalProperties: {
          type: 'object',
          properties: {
            prefix: { type: 'string' },
            pattern: { type: 'string' },
            resetCycle: { type: 'string', enum: ['daily', 'monthly', 'yearly', 'never'] },
            description: { type: 'string' },
          },
        },
      },
      documentStyles: { type: 'object', description: '문서별 스타일 오버라이드' },
      customBlocks: { type: 'array', description: '커스텀 블록 목록' },
    },
  },

  // ============================================================
  // 4. 유틸리티 함수
  // ============================================================

  /**
   * 현재 활성 테넌트 ID 저장 키
   */
  CURRENT_TENANT_KEY: 'currentTenantId',

  /**
   * 테넌트 시퀀스 저장 키 패턴
   */
  SEQUENCE_KEY_PATTERN: 'tenant_{tenantId}_seq_{docType}_{date}',

  /**
   * 마스터 데이터 저장 키 패턴
   */
  MASTER_DATA_KEY_PATTERN: 'tenant_{tenantId}_master_{masterType}',

  // ============================================================
  // 5. 기준정보 마스터 데이터 스키마 (테넌트별 분리)
  // ============================================================
  masterDataSchema: {
    // 품목기준관리
    'item-master': {
      id: 'item-master',
      label: '품목기준관리',
      description: '품목 분류, 단위, 품목유형 등',
      tables: [
        { id: 'itemCategories', label: '품목 분류', keyField: 'code' },
        { id: 'itemUnits', label: '단위', keyField: 'code' },
        { id: 'itemTypes', label: '품목 유형', keyField: 'code' },
        { id: 'itemCodeRules', label: '품목코드 규칙', keyField: 'type' },
      ],
    },
    // 공정기준관리
    'process-master': {
      id: 'process-master',
      label: '공정기준관리',
      description: '공정 유형, 작업장, 설비 등',
      tables: [
        { id: 'processTypes', label: '공정 유형', keyField: 'code' },
        { id: 'workCenters', label: '작업장', keyField: 'code' },
        { id: 'equipments', label: '설비', keyField: 'code' },
        { id: 'processRoutes', label: '공정 순서', keyField: 'id' },
      ],
    },
    // 품질기준관리
    'quality-master': {
      id: 'quality-master',
      label: '품질기준관리',
      description: '검사 항목, 기준, 판정 등',
      tables: [
        { id: 'inspectionItems', label: '검사 항목', keyField: 'code' },
        { id: 'inspectionCriteria', label: '검사 기준', keyField: 'id' },
        { id: 'defectTypes', label: '불량 유형', keyField: 'code' },
        { id: 'qualityGrades', label: '품질 등급', keyField: 'code' },
      ],
    },
    // 현장기준관리
    'site-master': {
      id: 'site-master',
      label: '현장기준관리',
      description: '현장 유형, 지역, 설치 조건 등',
      tables: [
        { id: 'siteTypes', label: '현장 유형', keyField: 'code' },
        { id: 'regions', label: '지역 코드', keyField: 'code' },
        { id: 'installConditions', label: '설치 조건', keyField: 'code' },
      ],
    },
    // 수주기준관리
    'order-master': {
      id: 'order-master',
      label: '수주기준관리',
      description: '수주 상태, 결제 조건, 납품 조건 등',
      tables: [
        { id: 'orderStatuses', label: '수주 상태', keyField: 'code' },
        { id: 'paymentTerms', label: '결제 조건', keyField: 'code' },
        { id: 'deliveryTerms', label: '납품 조건', keyField: 'code' },
        { id: 'orderTypes', label: '수주 유형', keyField: 'code' },
      ],
    },
    // 생산기준관리
    'production-master': {
      id: 'production-master',
      label: '생산기준관리',
      description: '생산 유형, 작업 상태, 우선순위 등',
      tables: [
        { id: 'productionTypes', label: '생산 유형', keyField: 'code' },
        { id: 'workStatuses', label: '작업 상태', keyField: 'code' },
        { id: 'priorities', label: '우선순위', keyField: 'code' },
        { id: 'shiftPatterns', label: '근무 패턴', keyField: 'code' },
      ],
    },
    // 출고기준관리
    'outbound-master': {
      id: 'outbound-master',
      label: '출고기준관리',
      description: '출고 유형, 운송 방법, 포장 유형 등',
      tables: [
        { id: 'outboundTypes', label: '출고 유형', keyField: 'code' },
        { id: 'shippingMethods', label: '운송 방법', keyField: 'code' },
        { id: 'packagingTypes', label: '포장 유형', keyField: 'code' },
        { id: 'carriers', label: '운송업체', keyField: 'code' },
      ],
    },
    // 채번관리
    'number-rule': {
      id: 'number-rule',
      label: '채번관리',
      description: '문서번호 채번 규칙',
      tables: [
        { id: 'numberingRules', label: '채번 규칙', keyField: 'docType' },
      ],
    },
    // 공통코드관리
    'code-rule': {
      id: 'code-rule',
      label: '공통코드관리',
      description: '품목코드, LOT번호, 거래처코드 규칙',
      tables: [
        { id: 'itemCodeRules', label: '품목코드 규칙', keyField: 'type' },
        { id: 'lotCodeRules', label: 'LOT번호 규칙', keyField: 'type' },
        { id: 'customerCodeRules', label: '거래처코드 규칙', keyField: 'type' },
      ],
    },
    // 견적수식관리
    'quote-formula': {
      id: 'quote-formula',
      label: '견적수식관리',
      description: '견적 계산 공식, 할인율, 마진율 등',
      tables: [
        { id: 'priceFormulas', label: '가격 공식', keyField: 'id' },
        { id: 'discountRules', label: '할인 규칙', keyField: 'code' },
        { id: 'marginRates', label: '마진율', keyField: 'category' },
        { id: 'laborRates', label: '노무비 단가', keyField: 'type' },
      ],
    },
    // 문서양식관리
    'document-template': {
      id: 'document-template',
      label: '문서양식관리',
      description: '문서 템플릿, 블록, 스타일 등',
      tables: [
        { id: 'documentTemplates', label: '문서 템플릿', keyField: 'id' },
        { id: 'blockLibrary', label: '블록 라이브러리', keyField: 'id' },
        { id: 'stylePresets', label: '스타일 프리셋', keyField: 'id' },
        { id: 'approvalLines', label: '결재라인', keyField: 'id' },
      ],
    },
    // 거래처관리 (판매관리 하위이지만 기준정보 성격)
    'customer': {
      id: 'customer',
      label: '거래처관리',
      description: '거래처 유형, 등급, 결제 조건 등',
      tables: [
        { id: 'customerTypes', label: '거래처 유형', keyField: 'code' },
        { id: 'customerGrades', label: '거래처 등급', keyField: 'code' },
        { id: 'creditTerms', label: '신용 조건', keyField: 'code' },
      ],
    },
    // 품목관리 (생산관리 하위이지만 기준정보 성격)
    'item': {
      id: 'item',
      label: '품목관리',
      description: '품목 마스터 데이터',
      tables: [
        { id: 'items', label: '품목 목록', keyField: 'code' },
        { id: 'bom', label: 'BOM', keyField: 'id' },
      ],
    },
  },
};

// ============================================================
// 테넌트 관리 헬퍼 함수들
// ============================================================

/**
 * 현재 활성 테넌트 가져오기
 */
export const getCurrentTenant = () => {
  const currentId = localStorage.getItem(tenantConfig.CURRENT_TENANT_KEY);
  if (currentId && tenantConfig.tenants[currentId]) {
    return tenantConfig.tenants[currentId];
  }
  // 기본 테넌트 반환
  const defaultTenant = Object.values(tenantConfig.tenants).find(t => t.isDefault);
  return defaultTenant || Object.values(tenantConfig.tenants)[0];
};

/**
 * 테넌트 전환
 */
export const setCurrentTenant = (tenantId) => {
  if (tenantConfig.tenants[tenantId]) {
    localStorage.setItem(tenantConfig.CURRENT_TENANT_KEY, tenantId);
    return true;
  }
  return false;
};

/**
 * 활성 테넌트 목록 가져오기
 */
export const getActiveTenants = () => {
  return Object.values(tenantConfig.tenants).filter(t => t.isActive);
};

/**
 * 테넌트별 회사정보 가져오기
 */
export const getTenantCompanyInfo = (tenantId = null) => {
  const tenant = tenantId
    ? tenantConfig.tenants[tenantId]
    : getCurrentTenant();
  return tenant?.companyInfo || {};
};

/**
 * 테넌트별 결재라인 가져오기
 */
export const getTenantApprovalLine = (lineType = 'default', tenantId = null) => {
  const tenant = tenantId
    ? tenantConfig.tenants[tenantId]
    : getCurrentTenant();
  return tenant?.approvalLines?.[lineType] || tenant?.approvalLines?.default;
};

/**
 * 테넌트별 채번규칙 가져오기 (시스템 기본값과 머지)
 */
export const getTenantNumberingRule = (docType, tenantId = null) => {
  const tenant = tenantId
    ? tenantConfig.tenants[tenantId]
    : getCurrentTenant();
  const tenantRule = tenant?.numberingRules?.[docType];
  const systemDefault = tenantConfig.systemDefaults.numbering;

  return {
    ...systemDefault,
    ...tenantRule,
  };
};

/**
 * 테넌트별 문서번호 생성
 */
export const generateTenantDocumentNo = (docType, date = new Date(), tenantId = null) => {
  const rule = getTenantNumberingRule(docType, tenantId);
  const tenant = tenantId
    ? tenantConfig.tenants[tenantId]
    : getCurrentTenant();

  // 날짜 포맷
  const year = date.getFullYear();
  const yy = String(year).slice(-2);
  const mm = String(date.getMonth() + 1).padStart(2, '0');
  const dd = String(date.getDate()).padStart(2, '0');

  // 시퀀스 키 생성
  let dateKey;
  switch (rule.resetCycle) {
    case 'daily':
      dateKey = `${yy}${mm}${dd}`;
      break;
    case 'monthly':
      dateKey = `${yy}${mm}`;
      break;
    case 'yearly':
      dateKey = `${yy}`;
      break;
    case 'never':
      dateKey = 'all';
      break;
    default:
      dateKey = `${yy}${mm}${dd}`;
  }

  const sequenceKey = tenantConfig.SEQUENCE_KEY_PATTERN
    .replace('{tenantId}', tenant.id)
    .replace('{docType}', docType)
    .replace('{date}', dateKey);

  // 시퀀스 가져오기 및 증가
  const currentSeq = parseInt(localStorage.getItem(sequenceKey) || '0', 10);
  const nextSeq = currentSeq + 1;
  localStorage.setItem(sequenceKey, String(nextSeq));

  // 패턴에 따라 문서번호 생성
  let docNo = rule.pattern || '{PREFIX}-{YYMMDD}-{##}';
  const digits = (docNo.match(/\{#+\}/)?.[0]?.length - 2) || 2;

  docNo = docNo
    .replace('{PREFIX}', rule.prefix)
    .replace('{YYYY}', String(year))
    .replace('{YY}', yy)
    .replace('{YYMM}', `${yy}${mm}`)
    .replace('{YYMMDD}', `${yy}${mm}${dd}`)
    .replace('{YYYYMMDD}', `${year}${mm}${dd}`)
    .replace('{MM}', mm)
    .replace('{DD}', dd)
    .replace(/\{#+\}/, String(nextSeq).padStart(digits, '0'));

  return docNo;
};

/**
 * 테넌트별 로고 정보 가져오기
 */
export const getTenantLogo = (tenantId = null) => {
  const tenant = tenantId
    ? tenantConfig.tenants[tenantId]
    : getCurrentTenant();
  return tenant?.logo || {};
};

/**
 * 테넌트별 인감 정보 가져오기
 */
export const getTenantSeals = (tenantId = null) => {
  const tenant = tenantId
    ? tenantConfig.tenants[tenantId]
    : getCurrentTenant();
  return tenant?.seals || {};
};

/**
 * 테넌트별 문서 스타일 가져오기 (시스템 기본값과 머지)
 */
export const getTenantDocumentStyle = (docType, tenantId = null) => {
  const tenant = tenantId
    ? tenantConfig.tenants[tenantId]
    : getCurrentTenant();
  const systemStyle = tenantConfig.systemDefaults.document;
  const tenantStyle = tenant?.documentStyles?.[docType] || {};

  return deepMerge(systemStyle, tenantStyle);
};

/**
 * 딥 머지 유틸리티
 */
const deepMerge = (target, source) => {
  const result = { ...target };
  for (const key in source) {
    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
      result[key] = deepMerge(result[key] || {}, source[key]);
    } else {
      result[key] = source[key];
    }
  }
  return result;
};

/**
 * 신규 테넌트 생성 (스키마 검증 포함)
 */
export const createTenant = (tenantData) => {
  const schema = tenantConfig.tenantSchema;

  // 필수 필드 검증
  for (const field of schema.required) {
    if (!tenantData[field]) {
      throw new Error(`필수 필드 누락: ${field}`);
    }
  }

  // ID 중복 검사
  if (tenantConfig.tenants[tenantData.id]) {
    throw new Error(`이미 존재하는 테넌트 ID: ${tenantData.id}`);
  }

  // 기본값 설정
  const newTenant = {
    createdAt: new Date().toISOString().split('T')[0],
    isActive: true,
    isDefault: false,
    approvalLines: {
      default: {
        id: 'default',
        name: '기본 결재',
        levels: [
          { id: 'write', label: '작성', role: '담당자', width: 60 },
          { id: 'approve', label: '승인', role: '대표', width: 60 },
        ],
      },
    },
    numberingRules: {},
    documentStyles: {},
    customBlocks: [],
    ...tenantData,
  };

  // 저장 (실제 구현에서는 API 호출)
  tenantConfig.tenants[newTenant.id] = newTenant;

  return newTenant;
};

/**
 * 테넌트 복제 (새 회사 생성 시 기존 설정 복사)
 */
export const cloneTenant = (sourceId, newTenantData) => {
  const source = tenantConfig.tenants[sourceId];
  if (!source) {
    throw new Error(`존재하지 않는 테넌트: ${sourceId}`);
  }

  const cloned = JSON.parse(JSON.stringify(source));
  delete cloned.id;
  delete cloned.isDefault;

  return createTenant({
    ...cloned,
    ...newTenantData,
  });
};

// ============================================================
// 마스터 데이터 관리 헬퍼 함수들
// ============================================================

/**
 * 마스터 데이터 저장 키 생성
 */
const getMasterDataKey = (masterType, tableId, tenantId = null) => {
  const tenant = tenantId
    ? tenantConfig.tenants[tenantId]
    : getCurrentTenant();
  return `tenant_${tenant.id}_master_${masterType}_${tableId}`;
};

/**
 * 테넌트별 마스터 데이터 가져오기
 * @param {string} masterType - 마스터 유형 (예: 'item-master', 'process-master')
 * @param {string} tableId - 테이블 ID (예: 'itemCategories', 'processTypes')
 * @param {string} tenantId - 테넌트 ID (null이면 현재 테넌트)
 * @returns {Array} 마스터 데이터 배열
 */
export const getTenantMasterData = (masterType, tableId, tenantId = null) => {
  const key = getMasterDataKey(masterType, tableId, tenantId);
  const stored = localStorage.getItem(key);
  return stored ? JSON.parse(stored) : [];
};

/**
 * 테넌트별 마스터 데이터 저장
 * @param {string} masterType - 마스터 유형
 * @param {string} tableId - 테이블 ID
 * @param {Array} data - 저장할 데이터 배열
 * @param {string} tenantId - 테넌트 ID (null이면 현재 테넌트)
 */
export const setTenantMasterData = (masterType, tableId, data, tenantId = null) => {
  const key = getMasterDataKey(masterType, tableId, tenantId);
  localStorage.setItem(key, JSON.stringify(data));
};

/**
 * 마스터 데이터에 항목 추가
 * @param {string} masterType - 마스터 유형
 * @param {string} tableId - 테이블 ID
 * @param {Object} item - 추가할 항목
 * @param {string} tenantId - 테넌트 ID
 * @returns {Object} 추가된 항목
 */
export const addMasterDataItem = (masterType, tableId, item, tenantId = null) => {
  const data = getTenantMasterData(masterType, tableId, tenantId);
  const schema = tenantConfig.masterDataSchema[masterType];
  const tableSchema = schema?.tables.find(t => t.id === tableId);

  // 키 필드 중복 검사
  if (tableSchema?.keyField && data.some(d => d[tableSchema.keyField] === item[tableSchema.keyField])) {
    throw new Error(`중복된 ${tableSchema.keyField}: ${item[tableSchema.keyField]}`);
  }

  // ID 자동 생성
  const newItem = {
    ...item,
    id: item.id || `${tableId}_${Date.now()}`,
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
  };

  data.push(newItem);
  setTenantMasterData(masterType, tableId, data, tenantId);
  return newItem;
};

/**
 * 마스터 데이터 항목 수정
 * @param {string} masterType - 마스터 유형
 * @param {string} tableId - 테이블 ID
 * @param {string} itemId - 수정할 항목 ID
 * @param {Object} updates - 수정 내용
 * @param {string} tenantId - 테넌트 ID
 * @returns {Object} 수정된 항목
 */
export const updateMasterDataItem = (masterType, tableId, itemId, updates, tenantId = null) => {
  const data = getTenantMasterData(masterType, tableId, tenantId);
  const index = data.findIndex(d => d.id === itemId);

  if (index === -1) {
    throw new Error(`항목을 찾을 수 없음: ${itemId}`);
  }

  data[index] = {
    ...data[index],
    ...updates,
    updatedAt: new Date().toISOString(),
  };

  setTenantMasterData(masterType, tableId, data, tenantId);
  return data[index];
};

/**
 * 마스터 데이터 항목 삭제
 * @param {string} masterType - 마스터 유형
 * @param {string} tableId - 테이블 ID
 * @param {string} itemId - 삭제할 항목 ID
 * @param {string} tenantId - 테넌트 ID
 * @returns {boolean} 삭제 성공 여부
 */
export const deleteMasterDataItem = (masterType, tableId, itemId, tenantId = null) => {
  const data = getTenantMasterData(masterType, tableId, tenantId);
  const filtered = data.filter(d => d.id !== itemId);

  if (filtered.length === data.length) {
    return false; // 삭제할 항목 없음
  }

  setTenantMasterData(masterType, tableId, filtered, tenantId);
  return true;
};

/**
 * 전체 마스터 데이터 스키마 가져오기
 */
export const getMasterDataSchema = () => {
  return tenantConfig.masterDataSchema;
};

/**
 * 특정 마스터 유형의 스키마 가져오기
 */
export const getMasterTypeSchema = (masterType) => {
  return tenantConfig.masterDataSchema[masterType];
};

/**
 * 테넌트의 모든 마스터 데이터 내보내기
 * @param {string} tenantId - 테넌트 ID (null이면 현재 테넌트)
 * @returns {Object} 모든 마스터 데이터
 */
export const exportTenantMasterData = (tenantId = null) => {
  const tenant = tenantId
    ? tenantConfig.tenants[tenantId]
    : getCurrentTenant();

  const exportData = {
    tenantId: tenant.id,
    tenantName: tenant.name,
    exportedAt: new Date().toISOString(),
    masterData: {},
  };

  // 모든 마스터 유형 순회
  for (const [masterType, schema] of Object.entries(tenantConfig.masterDataSchema)) {
    exportData.masterData[masterType] = {};
    for (const table of schema.tables) {
      exportData.masterData[masterType][table.id] = getTenantMasterData(masterType, table.id, tenant.id);
    }
  }

  return exportData;
};

/**
 * 마스터 데이터 가져오기 (다른 테넌트에서 복사)
 * @param {Object} importData - 가져올 데이터
 * @param {string} targetTenantId - 대상 테넌트 ID (null이면 현재 테넌트)
 * @param {boolean} overwrite - 기존 데이터 덮어쓰기 여부
 */
export const importTenantMasterData = (importData, targetTenantId = null, overwrite = false) => {
  const tenant = targetTenantId
    ? tenantConfig.tenants[targetTenantId]
    : getCurrentTenant();

  if (!importData.masterData) {
    throw new Error('유효하지 않은 가져오기 데이터');
  }

  for (const [masterType, tables] of Object.entries(importData.masterData)) {
    for (const [tableId, data] of Object.entries(tables)) {
      if (overwrite) {
        // 덮어쓰기
        setTenantMasterData(masterType, tableId, data, tenant.id);
      } else {
        // 기존 데이터에 병합
        const existing = getTenantMasterData(masterType, tableId, tenant.id);
        const merged = [...existing];

        for (const item of data) {
          if (!existing.some(e => e.id === item.id)) {
            merged.push(item);
          }
        }

        setTenantMasterData(masterType, tableId, merged, tenant.id);
      }
    }
  }
};

/**
 * 테넌트 간 마스터 데이터 복사
 * @param {string} sourceTenantId - 원본 테넌트 ID
 * @param {string} targetTenantId - 대상 테넌트 ID
 * @param {Array} masterTypes - 복사할 마스터 유형 배열 (빈 배열이면 전체)
 * @param {boolean} overwrite - 덮어쓰기 여부
 */
export const copyMasterDataBetweenTenants = (sourceTenantId, targetTenantId, masterTypes = [], overwrite = false) => {
  const typesToCopy = masterTypes.length > 0
    ? masterTypes
    : Object.keys(tenantConfig.masterDataSchema);

  for (const masterType of typesToCopy) {
    const schema = tenantConfig.masterDataSchema[masterType];
    if (!schema) continue;

    for (const table of schema.tables) {
      const sourceData = getTenantMasterData(masterType, table.id, sourceTenantId);

      if (overwrite) {
        setTenantMasterData(masterType, table.id, sourceData, targetTenantId);
      } else {
        const targetData = getTenantMasterData(masterType, table.id, targetTenantId);
        const merged = [...targetData];

        for (const item of sourceData) {
          if (!targetData.some(t => t.id === item.id)) {
            merged.push({
              ...item,
              id: `${item.id}_copy_${Date.now()}`, // 새 ID 부여
              copiedFrom: sourceTenantId,
              copiedAt: new Date().toISOString(),
            });
          }
        }

        setTenantMasterData(masterType, table.id, merged, targetTenantId);
      }
    }
  }
};

/**
 * 마스터 데이터 검색
 * @param {string} masterType - 마스터 유형
 * @param {string} tableId - 테이블 ID
 * @param {Object} query - 검색 조건 { field: value }
 * @param {string} tenantId - 테넌트 ID
 * @returns {Array} 검색 결과
 */
export const searchMasterData = (masterType, tableId, query, tenantId = null) => {
  const data = getTenantMasterData(masterType, tableId, tenantId);

  return data.filter(item => {
    for (const [field, value] of Object.entries(query)) {
      if (typeof value === 'string') {
        // 문자열 부분 일치
        if (!item[field]?.toString().toLowerCase().includes(value.toLowerCase())) {
          return false;
        }
      } else {
        // 정확한 일치
        if (item[field] !== value) {
          return false;
        }
      }
    }
    return true;
  });
};

/**
 * 테넌트 전환 시 콜백 등록
 * (UI에서 테넌트 전환 시 화면 갱신용)
 */
const tenantChangeCallbacks = [];

export const onTenantChange = (callback) => {
  tenantChangeCallbacks.push(callback);
  return () => {
    const index = tenantChangeCallbacks.indexOf(callback);
    if (index > -1) tenantChangeCallbacks.splice(index, 1);
  };
};

/**
 * 테넌트 전환 (콜백 포함)
 */
export const switchTenant = (tenantId) => {
  if (setCurrentTenant(tenantId)) {
    tenantChangeCallbacks.forEach(cb => cb(getCurrentTenant()));
    return true;
  }
  return false;
};

export default tenantConfig;
