teraWeb/frontend/internal/mock/mock_data.go

package mock

import (
	"fmt"
	"strconv"
	"strings"

	"teraclone/internal/config"
)

type PageData struct {
	AppName       string
	MockMode      bool
	CurrentUser   string
	CurrentRole   string
	WorkspaceID   string
	CurrentPath   string
	Title         string
	Section       string
	Breadcrumbs   []string
	WorkspaceTabs []WorkspaceTab
	Menu          []MenuGroup
	SubTabs       []SubTab
	Blocks        []ContentBlock
}

type WorkspaceTab struct {
	Key    string
	Label  string
	Path   string
	Active bool
}

type MenuGroup struct {
	Label    string
	Icon     string
	Path     string
	Active   bool
	Expanded bool
	Children []MenuChild
}

type MenuChild struct {
	Label  string
	Path   string
	Active bool
}

type SubTab struct {
	Label  string
	Path   string
	Active bool
}

type ContentBlock struct {
	Kind      string
	Title     string
	Subtitle  string
	PortLinks []PortLink
	KeyValues []KeyValue
	Form      *FormData
	Table     *TableData
	Action    *ActionPanel
	Tool      *ToolData
	Terminal  *SerialTerminalData
	Modal     *ModalData
	Message   string
}

type SerialTerminalData struct {
	Port    int
	Options []Option
}

type PortLink struct {
	Number int
	Up     bool
	Blink  bool
}

type KeyValue struct {
	Key   string
	Value string
}

type FormData struct {
	Action         string
	PrimaryLabel   string
	SecondaryLabel string
	Fields         []FormField
	PortTargets    []PortTarget
	Notes          []string
}

type FormField struct {
	Label       string
	Name        string
	Type        string
	Value       string
	Placeholder string
	Required    bool
	Disabled    bool
	Fixed       bool
	Checked     bool
	Hint        string
	Rows        int
	Min         string
	Max         string
	Accept      string
	Options     []Option
	Group       string
	Hidden      bool
}

type Option struct {
	Label    string
	Value    string
	Selected bool
}

type PortTarget struct {
	Number  int
	Checked bool
}

type TableData struct {
	Columns        []string
	Rows           []TableRow
	EmptyMessage   string
	PrimaryLabel   string
	SecondaryLabel string
}

type TableRow struct {
	Cells   []string
	Actions []RowAction
}

type RowAction struct {
	Label   string
	Action  string
	Variant string
	Target  string
}

type ActionPanel struct {
	Description string
	Buttons     []ActionButton
}

type ActionButton struct {
	Label   string
	Action  string
	Variant string
}

type ToolData struct {
	Action       string
	PrimaryLabel string
	Tabs         []SubTab
	Fields       []FormField
	Result       string
}

type ModalData struct {
	Root    string
	Title   string
	Message string
	Fields  []FormField
	Buttons []ActionButton
}

func ResolvePage(path string) (PageData, bool) {
	switch {
	case path == "/":
		return dashboardPage(), true
	case path == "/config/save":
		return actionPage(path, "설정 저장", "보류 중인 설정을 장비 구성 파일에 영구 저장합니다.", "save-config"), true
	case path == "/ports/restart":
		return actionPage(path, "포트 재시작", "포트 설정 화면에서 선택한 채널을 백엔드에서 재시작합니다.", "restart-ports"), true
	case path == "/device/factory-reset":
		return newPage(path, "공장 초기화", "공장 초기화", []string{"공장 초기화"}, nil, []ContentBlock{{
			Kind: "form", Title: "공장 초기화", Subtitle: "저장된 장비 구성을 기본값으로 되돌리는 작업입니다. 실행 전 구성 백업을 권장합니다.",
			Form: &FormData{Action: "factory-reset", PrimaryLabel: "공장 초기화 실행", Fields: []FormField{
				{Label: "현재 계정 비밀번호", Name: "password", Type: "password", Required: true, Hint: "현재 로그인한 계정의 비밀번호로 인증합니다."},
			}, Notes: []string{
				"네트워크·포트·외부 인증 등 저장된 구성과 보류 중인 변경이 기본값으로 초기화됩니다.",
				"사용자·사용자 정의 그룹·세션·로그·인증서·저장된 인증정보와 장비 내 진단 파일을 삭제합니다. 기본 계정 terauser / terauser만 복원됩니다.",
				"초기화가 완료되면 자동 재부팅됩니다. 설치된 펌웨어는 유지됩니다.",
				"연결이 끊어집니다. 재부팅 후 기본 접속 주소에서 terauser / terauser로 로그인하세요.",
			}},
		}}), true
	case path == "/device/restart":
		return actionPage(path, "장치 재시작", "현재 장비의 시스템 재시작 작업을 요청합니다.", "restart-device"), true
	case strings.HasPrefix(path, "/network/"):
		return networkPage(path)
	case strings.HasPrefix(path, "/ports/"):
		return portPage(path)
	case strings.HasPrefix(path, "/port-debug"):
		return portDebugPage(path)
	case strings.HasPrefix(path, "/admin/"):
		return adminPage(path)
	case strings.HasPrefix(path, "/settings/"):
		return settingsPage(path)
	case strings.HasPrefix(path, "/tools/"):
		return toolsPage(path)
	case strings.HasPrefix(path, "/logs/"):
		return logsPage(path)
	case path == "/port-status":
		return portStatusPage(), true
	case path == "/password":
		return passwordPage(), true
	default:
		return PageData{}, false
	}
}

func dashboardPage() PageData {
	return newPage("/", "대시보드", "대시보드", []string{"대시보드"}, nil, []ContentBlock{
		{Kind: "port-links", Title: "포트 링크 상태", PortLinks: portLinks()},
		{
			Kind:  "key-values",
			Title: "시스템 정보",
			KeyValues: []KeyValue{
				{"모델", "TERA CORA-X48 PRO K"},
				{"빌드번호", "N010-0020-2609-0062"},
				{"시리얼번호", "RMM4027N850000026090062"},
				{"펌웨어", "6.4.6004"},
				{"가동 시간", "2일 17시간 24분 50초"},
				{"시스템 시간", "2026년 6월 24일 수요일 오후 2시 03분 22초"},
				{"CPU 평균", "0.46 / 0.45 / 0.41"},
			},
		},
		{
			Kind:  "key-values",
			Title: "네트워크 정보",
			KeyValues: []KeyValue{
				{"인터페이스 1", "eth0 / 192.168.0.233 / 1000Mbps / 링크 연결"},
				{"인터페이스 2", "eth1 / 192.168.200.233 / 1000Mbps / Unknown"},
				{"MAC 주소", "6C:B3:50:0D:36:12"},
				{"다운로드 속도", "0 B/s"},
				{"업로드 속도", "0 B/s"},
			},
		},
		{
			Kind:  "key-values",
			Title: "리소스 상태",
			KeyValues: []KeyValue{
				{"CPU 사용률", "14%"},
				{"전체 메모리", "2 GB"},
				{"사용 중 메모리", "1.3 GB"},
				{"남은 메모리", "768 MB"},
				{"메모리 사용률", "62.5%"},
				{"온도", "53.8°C"},
				{"활성 세션", "0"},
				{"활성 알람", "0"},
			},
		},
		{
			Kind:  "key-values",
			Title: "포트 사용 현황",
			KeyValues: []KeyValue{
				{"활성 포트", "0"},
				{"누적 수신", "0 B"},
				{"누적 송신", "0 B"},
				{"1위", "CH01 / 0 B"},
				{"2위", "CH02 / 0 B"},
				{"3위", "CH03 / 0 B"},
				{"4위", "CH04 / 0 B"},
				{"5위", "CH05 / 0 B"},
			},
		},
	})
}

func networkPage(path string) (PageData, bool) {
	subtabs := []SubTab{
		{"인터페이스 1", "/network/interface-1", path == "/network/interface-1"},
		{"인터페이스 2", "/network/interface-2", path == "/network/interface-2"},
		{"호스트 설정", "/network/host", path == "/network/host"},
		{"고급 설정", "/network/advanced", path == "/network/advanced"},
		{"DDNS 설정", "/network/ddns", path == "/network/ddns"},
	}

	switch path {
	case "/network/interface-1", "/network/interface-2":
		label := "인터페이스 1"
		addr := "192.168.0.233"
		gateway := "192.168.0.1"
		if path == "/network/interface-2" {
			label = "인터페이스 2"
			addr = "192.168.200.233"
			gateway = "192.168.200.1"
		}
		return newPage(path, "네트워크 설정", "네트워크 설정", []string{"네트워크 설정", label}, subtabs, []ContentBlock{
			formBlock(label+" IPv4 설정", "network-apply", []FormField{
				toggleField("DHCP 사용", "dhcp", false),
				textField("IPv4 주소", "address", addr, true),
				textField("서브넷 마스크", "netmask", "255.255.255.0", true),
				textField("게이트웨이", "gateway", gateway, false),
				textField("DNS 서버 1", "dns1", "8.8.8.8", false),
				textField("DNS 서버 2", "dns2", "1.1.1.1", false),
				groupedField(selectField("IPv6 모드", "ipv6mode", "Auto", []string{"Auto", "Disable", "Static"}), "ipv6", true),
				groupedField(textField("IPv6 주소", "ipv6address", "", false), "ipv6", true),
				groupedField(textField("Prefix Length", "prefix", "64", false), "ipv6", true),
				groupedField(textField("IPv6 게이트웨이", "ipv6gateway", "", false), "ipv6", true),
				groupedField(textField("IPv6 DNS 서버 1", "ipv6dns1", "", false), "ipv6", true),
				groupedField(textField("IPv6 DNS 서버 2", "ipv6dns2", "", false), "ipv6", true),
			}, "적용", ""),
		}), true
	case "/network/host":
		return newPage(path, "네트워크 설정", "네트워크 설정", []string{"네트워크 설정", "호스트 설정"}, subtabs, []ContentBlock{
			formBlock("호스트 설정", "network-host", []FormField{
				textField("호스트 이름", "hostname", "teraclone-x48", true),
			}, "적용", ""),
		}), true
	case "/network/advanced":
		return newPage(path, "네트워크 설정", "네트워크 설정", []string{"네트워크 설정", "고급 설정"}, subtabs, []ContentBlock{
			formBlock("운영 모드", "network-advanced", []FormField{
				selectOptionsField("운영 모드", "mode", "single", []Option{{Label: "Single", Value: "single"}, {Label: "OOB", Value: "oob"}}),
				selectOptionsField("고급 네트워크 모드", "advancedMode", "single", []Option{{Label: "Single", Value: "single"}, {Label: "Bonding", Value: "bonding"}, {Label: "Bridge", Value: "bridge"}}),
				groupedField(selectOptionsField("본딩 모드", "bondMode", "active-backup", []Option{{Label: "로드 밸런싱", Value: "balance-rr"}, {Label: "링크 중복", Value: "active-backup"}}), "bond-settings", true),
				groupedField(boundedNumberField("링크 감지 시간(ms)", "bondMii", "50", true, "1", "10000"), "bond-settings", true),
				groupedField(toggleField("브리지 STP 사용", "bridgeSTP", false), "bridge-settings", true),
				groupedField(fixedTextField("OOB 주 인터페이스", "primary", "Interface-1 (eth0)"), "oob-settings", true),
				groupedField(fixedTextField("OOB 예비 인터페이스", "fallback", "Interface-2 (eth1)"), "oob-settings", true),
				groupedField(textField("상태 확인 대상", "healthTarget", "1.1.1.1", true), "oob-settings", true),
				groupedField(textField("확인 주기(초)", "healthInterval", "10", true), "oob-settings", true),
				groupedField(textField("전환 실패 횟수", "failureThreshold", "3", true), "oob-settings", true),
			}, "적용", ""),
		}), true
	case "/network/ddns":
		return newPage(path, "네트워크 설정", "네트워크 설정", []string{"네트워크 설정", "DDNS 설정"}, subtabs, []ContentBlock{
			formBlock("DDNS 설정", "network-ddns", []FormField{
				toggleField("DDNS 사용", "ddns", false),
				selectField("DNS 공급자", "provider", "dnspod", []string{"dnspod", "dyndns", "cloudflare", "noip", "freedns", "dynv6", "freemyip", "cloudxns", "3322", "custom"}),
				toggleField("DDNS IPv4 사용", "ipv4Enabled", true),
				textField("사용자 이름(ID)", "username", "", false),
				passwordField("비밀번호(Token/Secret)", "password", ""),
				textField("IPv4 도메인", "ipv4Domain", "", false),
				textField("IP 확인 주소 (Check IP URL)", "checkIp", "", false),
				textField("Custom Provider", "customProvider", "", false),
				textField("Custom Provider Path", "customPath", "", false),
			}, "적용", ""),
		}), true
	default:
		return PageData{}, false
	}
}

func portPage(path string) (PageData, bool) {
	parts := strings.Split(strings.Trim(path, "/"), "/")
	if len(parts) != 3 || parts[0] != "ports" {
		return PageData{}, false
	}

	portID, err := strconv.Atoi(parts[1])
	if err != nil || portID < 1 || portID > 48 {
		return PageData{}, false
	}

	subPath := parts[2]
	subtabs := []SubTab{
		{"매개변수", fmt.Sprintf("/ports/%d/parameters", portID), subPath == "parameters"},
		{"동작 설정 1", fmt.Sprintf("/ports/%d/operation-1", portID), subPath == "operation-1"},
		{"동작 설정 2", fmt.Sprintf("/ports/%d/operation-2", portID), subPath == "operation-2"},
		{"데이터 로그", fmt.Sprintf("/ports/%d/data-log", portID), subPath == "data-log"},
	}

	switch subPath {
	case "parameters":
		return newPortPage(path, portID, subtabs, []ContentBlock{
			portSelectorBlock(),
			{
				Kind:  "form",
				Title: fmt.Sprintf("포트 설정 / Port %d", portID),
				Form: &FormData{
					Action:       "#",
					PrimaryLabel: "적용",
					Fields: []FormField{
						selectField("시리얼 타입", "serialType", "rs232", []string{"rs232"}),
						selectField("Baudrate", "baudrate", "115200", []string{"110", "300", "600", "1200", "2400", "4800", "9600", "19200", "38400", "57600", "115200", "230400", "460800"}),
						selectField("Databit", "databit", "8", []string{"5", "6", "7", "8"}),
						selectField("Parity", "parity", "none", []string{"none", "odd", "even", "space", "mark"}),
						selectField("Stopbit", "stopbit", "1", []string{"1", "1.5", "2"}),
						selectField("Flow control", "flow", "none", []string{"none", "rtscts", "xonxoff"}),
						selectField("RTS control", "rts", "auto", []string{"auto", "on", "off"}),
						selectField("DTR control", "dtr", "auto", []string{"auto", "on", "off"}),
						toggleField("Ignore jammed", "ignore", false),
					},
					PortTargets: portTargets(portID),
				},
			},
		}), true
	case "operation-1":
		return newPortPage(path, portID, subtabs, []ContentBlock{
			portSelectorBlock(),
			formBlock("동작 설정 1 · eth0", "port-operation-1", []FormField{
				portModeField("reverse_ssh"),
				fixedTextField("Listen Port", "port", fmt.Sprintf("%d", 10000+portID)),
				fixedTextField("Keep alive(초)", "keepalive", "3"),
				fixedTextField("ACK 타임아웃(ms)", "timeout", "10000"),
				fixedTextField("접속(유휴) 타임아웃(ms)", "connectionTimeout", "0"),
				boundedNumberField("최대 세션 수", "maxClients", "4", true, "1", "4"),
				authenticationField(),
				selectField("줄바꿈", "newline", "cr", []string{"cr", "lf", "crlf"}),
				shortcutField("제어 단축키", "controlShortcut", "^]", "Ctrl+] 후 T/Q/B/I/? 명령을 사용합니다."),
				shortcutField("전환 단축키", "switchShortcut", "^T", "Reverse 모드의 현재 세션과 동시 접속 유지 상태를 확인합니다."),
				shortcutField("세션 종료 단축키", "quitShortcut", "^Q", "현재 터미널 세션만 종료합니다."),
				shortcutField("Break 단축키(선택)", "breakShortcut", "", "비워두면 직접 단축키는 사용하지 않습니다. 예: ^B"),
				shortcutField("인터럽트 단축키(선택)", "interruptShortcut", "", "비워두면 사용하지 않습니다. 예: ^X"),
			}, "적용", ""),
		}), true
	case "operation-2":
		return newPortPage(path, portID, subtabs, []ContentBlock{
			portSelectorBlock(),
			formBlock("동작 설정 2 · eth1", "port-operation-2", []FormField{
				portModeField("disabled"),
				fixedTextField("Listen Port", "port", fmt.Sprintf("%d", 10000+portID)),
				fixedTextField("Keep alive(초)", "keepalive", "3"),
				fixedTextField("ACK 타임아웃(ms)", "timeout", "10000"),
				fixedTextField("접속(유휴) 타임아웃(ms)", "connectionTimeout", "0"),
				fixedTextField("최대 세션 수 (동작 설정 1과 공유)", "maxClients", "4"),
				authenticationField(),
				selectField("줄바꿈", "newline", "cr", []string{"cr", "lf", "crlf"}),
				shortcutField("제어 단축키", "controlShortcut", "^]", "Ctrl+] 후 T/Q/B/I/? 명령을 사용합니다."),
				shortcutField("전환 단축키", "switchShortcut", "^T", "Reverse 모드의 현재 세션과 동시 접속 유지 상태를 확인합니다."),
				shortcutField("세션 종료 단축키", "quitShortcut", "^Q", "현재 터미널 세션만 종료합니다."),
				shortcutField("Break 단축키(선택)", "breakShortcut", "", "비워두면 직접 단축키는 사용하지 않습니다. 예: ^B"),
				shortcutField("인터럽트 단축키(선택)", "interruptShortcut", "", "비워두면 사용하지 않습니다. 예: ^X"),
			}, "적용", ""),
		}), true
	case "data-log":
		return newPortPage(path, portID, subtabs, []ContentBlock{
			portSelectorBlock(),
			formBlock("데이터 로그", "port-data-log", []FormField{
				toggleField("Receive 기록", "read", true),
				toggleField("Send 기록", "send", true),
				toggleField("타임스탬프 표시", "showTimestamp", true),
				toggleField("방향 표시", "showDirection", true),
				toggleField("사용자 표시", "showUsername", false),
				toggleField("IP 주소 표시", "showIP", false),
				toggleField("포트 표시", "showPort", false),
				selectField("로그 형식", "format", "ascii", []string{"ascii", "hex"}),
			}, "적용", ""),
		}), true
	default:
		return PageData{}, false
	}
}

func portSelectorBlock() ContentBlock {
	return ContentBlock{
		Kind:      "port-selector",
		Title:     "포트 선택",
		PortLinks: portLinks(),
	}
}

func portDebugPage(path string) (PageData, bool) {
	portID := 1
	if path != "/port-debug" {
		parts := strings.Split(strings.Trim(path, "/"), "/")
		if len(parts) != 2 || parts[0] != "port-debug" {
			return PageData{}, false
		}
		parsed, err := strconv.Atoi(parts[1])
		if err != nil || parsed < 1 || parsed > 48 {
			return PageData{}, false
		}
		portID = parsed
	}

	options := make([]Option, 0, 48)
	for number := 1; number <= 48; number++ {
		options = append(options, Option{
			Label:    fmt.Sprintf("CH%02d / Port %d", number, number),
			Value:    strconv.Itoa(number),
			Selected: number == portID,
		})
	}

	return newPage(path, "직접 연결 모드", fmt.Sprintf("직접 연결 모드 / Port %d", portID), []string{"직접 연결 모드"}, nil, []ContentBlock{
		{
			Kind:  "serial-terminal",
			Title: "시리얼 포트 CMD 콘솔",
			Terminal: &SerialTerminalData{
				Port:    portID,
				Options: options,
			},
		},
	}), true
}

func adminPage(path string) (PageData, bool) {
	switch path {
	case "/admin/users":
		return newPage(path, "관리자 운영", "사용자 계정", []string{"관리자 운영", "사용자 계정"}, nil, []ContentBlock{
			tableBlock("사용자 계정", []string{"상태", "사용자 이름", "역할", "그룹", "비밀번호", "포트 권한"}, nil, "사용자 추가", ""),
			userAccountModalBlock(),
		}), true
	case "/admin/auth/radius":
		return newPage(path, "관리자 운영", "인증 서버", []string{"관리자 운영", "인증 서버", "RADIUS"}, authServerTabs(path), []ContentBlock{
			formBlock("RADIUS 인증", "external-auth-radius", []FormField{
				toggleField("RADIUS 사용", "enabled", false),
				textField("서버 주소", "host", "", true),
				boundedNumberField("인증 포트", "port", "1645", true, "1", "65535"),
				passwordField("공유 Secret", "secret", "기존 값을 유지하려면 비워두세요"),
				boundedNumberField("응답 타임아웃(초)", "timeout", "5", true, "1", "30"),
				selectOptionsField("외부 사용자 기본 역할", "defaultRole", "port_operator", roleOptions()),
			}, "적용", ""),
		}), true
	case "/admin/auth/tacacs":
		return newPage(path, "관리자 운영", "인증 서버", []string{"관리자 운영", "인증 서버", "TACACS+"}, authServerTabs(path), []ContentBlock{
			formBlock("TACACS+ 인증", "external-auth-tacacs", []FormField{
				toggleField("TACACS+ 사용", "enabled", false),
				textField("서버 주소", "host", "", true),
				boundedNumberField("인증 포트", "port", "49", true, "1", "65535"),
				passwordField("공유 Secret", "secret", "기존 값을 유지하려면 비워두세요"),
				boundedNumberField("응답 타임아웃(초)", "timeout", "5", true, "1", "30"),
				selectOptionsField("외부 사용자 기본 역할", "defaultRole", "port_operator", roleOptions()),
			}, "적용", ""),
		}), true
	case "/admin/address-filter":
		return newPage(path, "관리자 운영", "주소 필터", []string{"관리자 운영", "주소 필터"}, addressFilterTabs(path), []ContentBlock{
			formBlock("관리 접속 주소 필터", "address-filter-policy", []FormField{
				toggleField("주소 필터 사용", "enabled", false),
				selectOptionsField("필터 방식", "mode", "blacklist", []Option{{Label: "차단 목록", Value: "blacklist", Selected: true}, {Label: "허용 목록", Value: "whitelist"}}),
			}, "적용", ""),
		}), true
	case "/admin/address-filter/ipv4", "/admin/address-filter/mac":
		return addressFilterListPage(path), true
	case "/admin/address-filter/ipv4/new", "/admin/address-filter/mac/new":
		return addressFilterNewPage(path), true
	case "/admin/snmp":
		return newPage(path, "관리자 운영", "SNMP", []string{"관리자 운영", "SNMP"}, nil, []ContentBlock{
			formBlock("SNMP Agent", "snmp-agent", []FormField{
				toggleField("SNMP 사용", "enabled", false),
				textField("장비 위치(sysLocation)", "location", "", false),
				textField("관리자 연락처(sysContact)", "contact", "", false),
				toggleField("SNMP v1", "v1", false),
				toggleField("SNMP v2c", "v2c", true),
				toggleField("SNMP v3", "v3", false),
				passwordField("Read Community", "roCommunity", "기존 값을 유지하려면 비워두세요"),
				passwordField("Write Community", "rwCommunity", "기존 값을 유지하려면 비워두세요"),
				textField("v3 사용자", "v3Username", "", false),
				selectOptionsField("v3 접근 권한", "v3Access", "read", []Option{{Label: "읽기", Value: "read", Selected: true}, {Label: "읽기/쓰기", Value: "write"}}),
				selectOptionsField("v3 인증", "v3Auth", "sha256", []Option{{Label: "없음", Value: "none"}, {Label: "MD5", Value: "md5"}, {Label: "SHA-1", Value: "sha1"}, {Label: "SHA-256", Value: "sha256", Selected: true}}),
				selectOptionsField("v3 암호화", "v3Privacy", "aes", []Option{{Label: "없음", Value: "none"}, {Label: "DES", Value: "des"}, {Label: "AES", Value: "aes", Selected: true}}),
				passwordField("v3 인증 키", "v3AuthKey", "기존 값을 유지하려면 비워두세요"),
				passwordField("v3 암호화 키", "v3PrivacyKey", "기존 값을 유지하려면 비워두세요"),
				toggleField("v3 사용자 사용", "v3UserEnabled", false),
			}, "적용", ""),
		}), true
	case "/admin/ssl":
		return newPage(path, "관리자 운영", "SSL 인증서", []string{"관리자 운영", "SSL 인증서"}, sslTabs(path), []ContentBlock{
			formBlock("사용 인증서", "tls-active", []FormField{
				selectOptionsField("활성 인증서", "activeCertificate", "", []Option{{Label: "인증서를 불러오는 중", Value: "", Selected: true}}),
			}, "적용", ""),
			tableBlock("인증서 목록", []string{"ID", "공통 이름", "유효 기간", "키", "상태", "관리"}, nil, "", ""),
		}), true
	case "/admin/ssl/new":
		return newPage(path, "관리자 운영", "SSL 인증서 생성", []string{"관리자 운영", "SSL 인증서", "새로 만들기"}, sslTabs(path), []ContentBlock{
			formBlock("자체 서명 인증서 생성", "tls-create", []FormField{
				fixedTextField("인증서 ID", "certificateID", "접속 주소로 자동 생성"),
				textField("공통 이름(CN)", "commonName", "", true),
				textField("국가(C)", "country", "KR", false),
				textField("시/도(ST)", "province", "", false),
				textField("도시(L)", "locality", "", false),
				textField("조직(O)", "organization", "", false),
				textField("부서(OU)", "organizationalUnit", "", false),
				textField("이메일", "email", "", false),
			}, "생성", ""),
		}), true
	case "/admin/ssl/import":
		return newPage(path, "관리자 운영", "SSL 인증서 가져오기", []string{"관리자 운영", "SSL 인증서", "가져오기"}, sslTabs(path), []ContentBlock{
			formBlock("PEM 인증서 가져오기", "tls-import", []FormField{
				fixedTextField("인증서 ID", "certificateID", "파일명으로 자동 생성"),
				fileField("인증서 파일", "certificateFile", ".pem,.crt,.cer", true),
				fileField("개인 키 파일", "privateKeyFile", ".pem,.key", false),
				passwordField("개인 키 비밀번호", "password", "암호화된 키인 경우 입력"),
			}, "가져오기", ""),
		}), true
	case "/admin/ssl/import-csr":
		return newPage(path, "관리자 운영", "CSR 내보내기", []string{"관리자 운영", "SSL 인증서", "CSR 내보내기"}, sslTabs(path), []ContentBlock{
			formBlock("인증서 서명 요청(CSR)", "tls-csr", []FormField{
				selectOptionsField("인증서", "certificateID", "", []Option{{Label: "인증서를 불러오는 중", Value: "", Selected: true}}),
				textField("공통 이름(CN)", "commonName", "", false),
				textField("조직(O)", "organization", "", false),
				textField("이메일", "email", "", false),
			}, "CSR 다운로드", ""),
		}), true
	case "/admin/backup/export", "/admin/backup/import", "/admin/backup/restore":
		if path == "/admin/backup/export" {
			return newPage(path, "관리자 운영", "구성 내보내기", []string{"관리자 운영", "백업/복원", "내보내기"}, backupTabs(path), []ContentBlock{
				formBlock("암호화 구성 백업", "config-export-encrypted", []FormField{
					passwordField("백업 파일 암호", "key", "8~64자"),
					passwordField("암호 확인", "confirmKey", "백업 파일 암호 재입력"),
					fixedTextField("백업 범위", "scope", "네트워크를 포함한 영구 설정 전체"),
				}, "백업 다운로드", ""),
			}), true
		}
		return newPage(path, "관리자 운영", "구성 복원", []string{"관리자 운영", "백업/복원", "복원"}, backupTabs(path), []ContentBlock{
			formBlock("암호화 백업 복원", "config-restore-encrypted", []FormField{
				fileField("백업 파일", "backupFile", ".json,.tera-config.json", true),
				passwordField("백업 파일 암호", "key", "내보낼 때 사용한 암호"),
				toggleField("네트워크 설정 포함", "includeNetwork", false),
				fixedTextField("안전 안내", "networkWarning", "네트워크 포함 시 현재 웹 연결이 끊길 수 있습니다"),
			}, "복원 및 적용", ""),
		}), true
	case "/admin/firmware":
		block := formBlock("펌웨어 업그레이드", "firmware-upgrade", []FormField{
			fileField("서명된 펌웨어 패키지", "firmwareFile", ".pkg,application/octet-stream", true),
		}, "업데이트 적용", "")
		return newPage(path, "관리자 운영", "펌웨어 업그레이드", []string{"관리자 운영", "펌웨어"}, nil, []ContentBlock{block}), true
	default:
		return PageData{}, false
	}
}

func settingsPage(path string) (PageData, bool) {
	switch path {
	case "/settings/alert/event":
		return newPage(path, "기타 설정", "알림 설정", []string{"기타 설정", "알림 설정", "시스템 이벤트"}, alertTabs(path), []ContentBlock{
			formBlock("시스템 이벤트 알림", "alarm-system-events", []FormField{
				toggleField("Cold start", "coldStart", true),
				toggleField("Warm start", "warmStart", true),
				toggleField("로그인 실패 임계값", "authFailures", true),
				toggleField("OOB 경로 전환", "linkFailover", true),
				toggleField("시리얼 링크 DOWN", "serialLinkDown", true),
				toggleField("이더넷 링크 DOWN", "ethernetLinkDown", true),
				toggleField("저장 공간 경고", "storagePressure", true),
				toggleField("메일로 전달", "deliveryEmail", false),
				toggleField("SNMP Trap으로 전달", "deliverySNMP", false),
				toggleField("Syslog로 전달", "deliverySyslog", true),
			}, "적용", ""),
		}), true
	case "/settings/alert/serial-event":
		return newPage(path, "기타 설정", "알림 설정", []string{"기타 설정", "알림 설정", "시리얼 이벤트"}, alertTabs(path), []ContentBlock{
			formBlock("포트별 시리얼 이벤트", "alarm-serial-events", []FormField{
				selectOptionsField("대상 포트", "channel", "CH01", channelSelectOptions()),
				toggleField("DCD 상태 변경", "dcd", false),
				toggleField("DSR 상태 변경", "dsr", false),
				toggleField("수신 키워드 감지", "keyword", false),
				textField("감지 키워드", "keywordValue", "", false),
				toggleField("메일로 전달", "deliveryEmail", false),
				toggleField("SNMP Trap으로 전달", "deliverySNMP", false),
				toggleField("Syslog로 전달", "deliverySyslog", true),
			}, "적용", ""),
		}), true
	case "/settings/alert/mail":
		return newPage(path, "기타 설정", "알림 설정", []string{"기타 설정", "알림 설정", "메일"}, alertTabs(path), []ContentBlock{
			formBlock("메일 알림", "alarm-email", []FormField{
				toggleField("메일 알림 사용", "enabled", false),
				textField("SMTP 서버", "smtp", "", true),
				boundedNumberField("SMTP 포트", "port", "587", true, "1", "65535"),
				toggleField("STARTTLS 사용", "starttls", true),
				toggleField("SMTP 인증 사용", "auth", false),
				textField("SMTP 사용자", "username", "", false),
				passwordField("SMTP 비밀번호", "password", "기존 값을 유지하려면 비워두세요"),
				textField("발신자", "from", "", true),
				textField("수신자", "to", "", true),
				textField("참조(CC)", "cc", "", false),
				textField("제목", "title", "TERA 장비 알림", false),
				textAreaField("본문", "content", "", 4),
			}, "적용", "테스트 발송"),
		}), true
	case "/settings/alert/snmp-trap-filter":
		return newPage(path, "기타 설정", "알림 설정", []string{"기타 설정", "알림 설정", "SNMP Trap"}, alertTabs(path), []ContentBlock{
			formBlock("SNMP Trap 대상", "alarm-snmp-trap", []FormField{
				toggleField("Trap 전송 사용", "enabled", false),
				fixedTextField("대상 ID", "targetID", "primary-trap"),
				textField("대상 주소", "host", "", true),
				boundedNumberField("대상 포트", "port", "162", true, "1", "65535"),
				selectOptionsField("버전", "version", "v2c", []Option{{Label: "v1", Value: "v1"}, {Label: "v2c", Value: "v2c", Selected: true}, {Label: "v3", Value: "v3"}}),
				textField("v3 사용자", "username", "", false),
				selectOptionsField("v3 인증", "authProtocol", "none", []Option{{Label: "없음", Value: "none", Selected: true}, {Label: "MD5", Value: "md5"}, {Label: "SHA-1", Value: "sha1"}, {Label: "SHA-256", Value: "sha256"}}),
				selectOptionsField("v3 암호화", "privacyProtocol", "none", []Option{{Label: "없음", Value: "none", Selected: true}, {Label: "DES", Value: "des"}, {Label: "AES", Value: "aes"}}),
				textField("v3 Engine ID", "engineID", "", false),
				passwordField("Community / 인증 키", "credential", "기존 값을 유지하려면 비워두세요"),
				passwordField("v3 암호화 키", "privacyKey", "기존 값을 유지하려면 비워두세요"),
			}, "적용", "테스트 전송"),
		}), true
	case "/settings/system-log/remote":
		tabs := systemLogSettingsTabs(path)
		block := formBlock("로그 서버", "apply-log-server", []FormField{
			toggleField("원격 로그 전송 사용", "remote", false),
			{Label: "로그 서버", Name: "server", Type: "text", Placeholder: "도메인 또는 IP[:포트]  예: 192.168.0.233:514", Hint: "포트를 생략하면 표준 Syslog 포트 514를 사용합니다."},
			selectField("전송 프로토콜", "protocol", "UDP", []string{"UDP", "TCP"}),
		}, "적용", "")
		block.Subtitle = "Syslog 서버를 도메인 또는 IP 주소로 지정합니다. 포트는 주소 뒤에 콜론(:)으로 입력할 수 있습니다."
		return newPage(path, "기타 설정", "시스템 로그 - 로그 서버", []string{"기타 설정", "시스템 로그", "로그 서버"}, tabs, []ContentBlock{block}), true
	case "/settings/system-log/status-event", "/settings/system-log/events":
		tabs := systemLogSettingsTabs(path)
		block := formBlock("로그 이벤트", "apply-log-events", []FormField{
			toggleField("시스템 이벤트 - 로컬 저장", "localSystem", true),
			toggleField("시스템 이벤트 - 원격 전송", "remoteSystem", false),
			toggleField("설정 변경 이벤트 - 로컬 저장", "localConfiguration", true),
			toggleField("설정 변경 이벤트 - 원격 전송", "remoteConfiguration", false),
			toggleField("운영 모드 이벤트 - 로컬 저장", "localOperation", true),
			toggleField("운영 모드 이벤트 - 원격 전송", "remoteOperation", false),
		}, "적용", "")
		block.Subtitle = "시스템 시작/재시작/로그인 실패, 설정 변경, 포트 운영 세션 이벤트의 저장 위치를 선택합니다."
		block.Form.Notes = []string{
			"시스템 이벤트: Cold start, Warm start, 로그인 실패",
			"설정 변경 이벤트: 사용자가 웹 또는 콘솔에서 장비 설정을 변경한 기록",
			"운영 모드 이벤트: Reverse SSH/Reverse Telnet 세션 연결 및 해제 기록",
		}
		return newPage(path, "기타 설정", "시스템 로그 - 로그 이벤트", []string{"기타 설정", "시스템 로그", "로그 이벤트"}, tabs, []ContentBlock{block}), true
	case "/settings/datetime":
		return simpleFormPage(path, "기타 설정", []string{"기타 설정", "날짜와 시간"}, "날짜와 시간", []FormField{
			selectField("시간대", "timezone", "Asia/Seoul", []string{"Asia/Seoul", "UTC", "America/Los_Angeles"}),
			toggleField("NTP 사용", "ntp", true),
			textField("NTP 서버 1", "ntp1", "time.google.com", false),
			textField("NTP 서버 2", "ntp2", "pool.ntp.org", false),
			textField("수동 날짜", "date", "", false),
			textField("수동 시간", "time", "", false),
		}), true
	default:
		return PageData{}, false
	}
}

func toolsPage(path string) (PageData, bool) {
	switch path {
	case "/tools/nettest/ping":
		fields := []FormField{
			textField("IP 주소 / 도메인 이름", "address", "192.168.0.100", true),
			numberField("핑 횟수", "count", "4", true),
			fixedTextField("핑 패킷 크기", "size", "56 bytes"),
			fixedTextField("핑 응답 타임아웃", "replyTimeout", "1초 (고정)"),
		}
		return newPage(path, "관리자 운영", "진단 도구", []string{"관리자 운영", "진단 도구"}, nil, []ContentBlock{
			{
				Kind:  "tool",
				Title: "핑 테스트",
				Tool: &ToolData{
					Action:       "#",
					PrimaryLabel: "테스트",
					Fields:       fields,
					Result:       "테스트를 실행하면 백엔드 진단 작업 결과가 여기에 표시됩니다.",
				},
			},
		}), true
	default:
		return PageData{}, false
	}
}

func logsPage(path string) (PageData, bool) {
	tabs := []SubTab{
		{Label: "시스템 로그", Path: "/logs/system", Active: path == "/logs/system"},
		{Label: "포트 로그", Path: "/logs/ports", Active: path == "/logs/ports"},
		{Label: "포트 상태 이벤트", Path: "/logs/links", Active: path == "/logs/links"},
	}
	limitOptions := []Option{
		{Label: "50건", Value: "50"},
		{Label: "100건", Value: "100"},
		{Label: "200건", Value: "200"},
		{Label: "500건", Value: "500"},
	}
	switch path {
	case "/logs/system":
		return newPage(path, "로그", "시스템 로그", []string{"로그", "시스템 로그"}, tabs, []ContentBlock{
			{
				Kind:     "form",
				Title:    "검색 조건",
				Subtitle: "일반 시스템 이벤트와 보존 대상 감사 기록을 조회합니다. 클리어는 감사 기록을 삭제하지 않습니다.",
				Form: &FormData{
					Action:         "#",
					PrimaryLabel:   "조회",
					SecondaryLabel: "검색 초기화",
					Fields: []FormField{
						{Label: "로그 종류", Name: "category", Type: "text", Hidden: true},
						selectOptionsField("등급", "severity", "", []Option{{Label: "전체", Value: ""}, {Label: "정보", Value: "info"}, {Label: "경고", Value: "warning"}, {Label: "치명적", Value: "critical"}}),
						{Label: "검색어", Name: "keyword", Type: "text", Placeholder: "소스 또는 메시지"},
						{Label: "시작 시간", Name: "from", Type: "datetime-local"},
						{Label: "종료 시간", Name: "to", Type: "datetime-local"},
						selectOptionsField("페이지당 표시", "limit", "100", limitOptions),
						selectField("다운로드 형식", "export_format", "CSV", []string{"CSV", "JSON", "JSONL"}),
						selectField("최대 다운로드 건수", "export_limit", "1000", []string{"100", "500", "1000", "5000"}),
						toggleField("자동 갱신 (5초)", "auto_refresh", true),
					},
				},
			},
			{
				Kind:     "table",
				Title:    "시스템 로그",
				Subtitle: "최신 이벤트가 위에 표시됩니다.",
				Table: &TableData{
					Columns:        []string{"시간", "등급", "분류", "발생 위치", "내용"},
					EmptyMessage:   "조건에 맞는 시스템 로그가 없습니다.",
					PrimaryLabel:   "새로고침",
					SecondaryLabel: "로그 다운로드",
				},
			},
		}), true
	case "/logs/ports":
		channelOptions := []Option{{Label: "전체 포트", Value: ""}}
		for port := 1; port <= 48; port++ {
			channelOptions = append(channelOptions, Option{Label: fmt.Sprintf("CH%02d", port), Value: fmt.Sprintf("CH%02d", port)})
		}
		return newPage(path, "로그", "포트 로그", []string{"로그", "포트 로그"}, tabs, []ContentBlock{
			{
				Kind:     "form",
				Title:    "검색 조건",
				Subtitle: "포트별 RX/TX 데이터·명령·접속/종료 기록을 조회합니다. UP/DOWN 변경은 포트 상태 이벤트에서 확인하세요.",
				Form: &FormData{
					Action:         "#",
					PrimaryLabel:   "조회",
					SecondaryLabel: "검색 초기화",
					Fields: []FormField{
						selectOptionsField("포트", "channel", "", channelOptions),
						{Label: "로그 종류", Name: "event_type", Type: "text", Hidden: true},
						selectOptionsField("방향", "direction", "", []Option{{Label: "전체", Value: ""}, {Label: "RX", Value: "RX"}, {Label: "TX", Value: "TX"}}),
						{Label: "사용자", Name: "actor", Type: "text", Placeholder: "사용자 이름"},
						{Label: "검색어", Name: "keyword", Type: "text", Placeholder: "명령, 결과 또는 메시지"},
						{Label: "시작 시간", Name: "from", Type: "datetime-local"},
						{Label: "종료 시간", Name: "to", Type: "datetime-local"},
						selectOptionsField("페이지당 표시", "limit", "100", limitOptions),
						selectField("다운로드 형식", "export_format", "CSV", []string{"CSV", "JSON", "JSONL"}),
						selectField("최대 다운로드 건수", "export_limit", "1000", []string{"100", "500", "1000", "5000"}),
						toggleField("자동 갱신 (5초)", "auto_refresh", true),
					},
				},
			},
			{
				Kind:     "table",
				Title:    "포트 로그",
				Subtitle: "포트별 통신 이력 · 내보내기는 현재 검색 조건과 최대 다운로드 건수 범위에 적용됩니다.",
				Table: &TableData{
					Columns:        []string{"시간", "포트", "유형", "방향", "사용자", "내용"},
					EmptyMessage:   "조건에 맞는 포트 로그가 없습니다.",
					PrimaryLabel:   "새로고침",
					SecondaryLabel: "로그 다운로드",
				},
			},
		}), true
	case "/logs/links":
		resourceOptions := []Option{{Label: "전체 포트", Value: ""}}
		for port := 1; port <= 48; port++ {
			resourceOptions = append(resourceOptions, Option{Label: fmt.Sprintf("CH%02d", port), Value: fmt.Sprintf("CH%02d", port)})
		}
		return newPage(path, "로그", "포트 상태 이벤트", []string{"로그", "포트 상태 이벤트"}, tabs, []ContentBlock{
			{
				Kind:     "form",
				Title:    "검색 조건",
				Subtitle: "포트의 UP/DOWN 및 제공되는 신호 변경 기록을 조회합니다. RX/TX 데이터·명령·접속 기록은 포트 로그에서 확인하세요.",
				Form: &FormData{
					Action:         "#",
					PrimaryLabel:   "조회",
					SecondaryLabel: "검색 초기화",
					Fields: []FormField{
						selectOptionsField("포트", "resource", "", resourceOptions),
						{Label: "이벤트 종류", Name: "event_type", Type: "text", Value: "transition", Hidden: true},
						selectOptionsField("상태", "state", "", []Option{{Label: "전체", Value: ""}, {Label: "UP", Value: "up"}, {Label: "DOWN", Value: "down"}, {Label: "Unknown", Value: "unknown"}}),
						{Label: "신호 / 검색어", Name: "keyword", Type: "text", Placeholder: "DCD, DSR, CTS 또는 메시지"},
						{Label: "시작 시간", Name: "from", Type: "datetime-local"},
						{Label: "종료 시간", Name: "to", Type: "datetime-local"},
						selectOptionsField("페이지당 표시", "limit", "100", limitOptions),
						selectField("다운로드 형식", "export_format", "CSV", []string{"CSV", "JSON", "JSONL"}),
						selectField("최대 다운로드 건수", "export_limit", "1000", []string{"100", "500", "1000", "5000"}),
						toggleField("자동 갱신 (5초)", "auto_refresh", true),
					},
					Notes: []string{"장비 하드웨어가 제공하지 않는 DCD/DSR 신호는 기록할 수 없습니다.", "수신 키워드는 포트 로그의 검색어로 조회할 수 있습니다."},
				},
			},
			{
				Kind:     "table",
				Title:    "포트 상태 이벤트",
				Subtitle: "상태 변경 기록만 조회·내보내기합니다.",
				Table: &TableData{
					Columns:        []string{"시간", "포트", "신호", "상태 변화", "유형", "내용"},
					EmptyMessage:   "조건에 맞는 포트 상태 이벤트가 없습니다.",
					PrimaryLabel:   "새로고침",
					SecondaryLabel: "로그 다운로드",
				},
			},
		}), true
	default:
		return PageData{}, false
	}
}

func systemLogSettingsTabs(path string) []SubTab {
	return []SubTab{
		{Label: "로그 서버", Path: "/settings/system-log/remote", Active: path == "/settings/system-log/remote"},
		{Label: "로그 이벤트", Path: "/settings/system-log/events", Active: path == "/settings/system-log/events" || path == "/settings/system-log/status-event"},
	}
}

func portStatusPage() PageData {
	options := make([]Option, 0, 48)
	for number := 1; number <= 48; number++ {
		options = append(options, Option{Label: fmt.Sprintf("CH%02d", number), Value: fmt.Sprintf("CH%02d", number)})
	}
	return newPage("/port-status", "포트 상태", "포트 상태", []string{"포트 상태"}, nil, []ContentBlock{
		formBlock("포트 별칭", "port-alias", []FormField{
			selectOptionsField("포트 선택", "channel", "CH01", options),
			textField("포트 별칭", "alias", "", false),
		}, "변경", ""),
		{
			Kind:  "table",
			Title: "포트 상태 요약",
			Table: &TableData{
				Columns:      []string{"포트", "상태", "별칭", "프로토콜", "세션", "RX/TX", "세션 1 IP", "세션 2 IP", "세션 3 IP", "세션 4 IP"},
				EmptyMessage: "데이터가 없습니다.",
			},
		},
	})
}

func passwordPage() PageData {
	return newPage("/password", "비밀번호 변경", "비밀번호 변경", []string{"비밀번호 변경"}, nil, []ContentBlock{
		formBlock("비밀번호 변경", "change-password", []FormField{
			{Label: "사용자 이름", Name: "username", Type: "text", Value: "terauser", Disabled: true},
			passwordField("기존 비밀번호", "oldPassword", ""),
			passwordField("새 비밀번호", "newPassword", ""),
			passwordField("비밀번호 확인", "confirmPassword", ""),
		}, "변경", ""),
	})
}

func actionPage(path string, title string, description string, action string) PageData {
	return newPage(path, title, title, []string{title}, nil, []ContentBlock{
		{
			Kind:  "action",
			Title: title,
			Action: &ActionPanel{
				Description: description,
				Buttons: []ActionButton{
					{Label: "실행", Action: action, Variant: "primary"},
					{Label: "취소", Action: "cancel", Variant: "secondary"},
				},
			},
		},
		modalBlock(title+" 확인", "이 작업은 백엔드 API를 통해 장비 구성에 반영됩니다.", []FormField{
			textAreaField("안내", "note", "작업 전 현재 구성과 서비스 상태를 확인하세요.", 4),
		}),
	})
}

func simpleFormPage(path string, section string, breadcrumbs []string, title string, fields []FormField) PageData {
	return newPage(path, section, title, breadcrumbs, nil, []ContentBlock{
		formBlock(title, "apply-"+sanitizePath(path), fields, "적용", ""),
	})
}

func tablePage(path string, title string, breadcrumbs []string, columns []string, rows []TableRow, subtabs []SubTab) PageData {
	return newPage(path, title, title, breadcrumbs, subtabs, []ContentBlock{
		tableBlock(title, columns, rows, "추가", "변경"),
	})
}

func newPortPage(path string, portID int, subtabs []SubTab, blocks []ContentBlock) PageData {
	return newPage(path, "포트 설정", fmt.Sprintf("포트 설정 / Port %d", portID), []string{"포트 설정", fmt.Sprintf("Port %d", portID)}, subtabs, blocks)
}

func newPage(path string, section string, title string, breadcrumbs []string, subtabs []SubTab, blocks []ContentBlock) PageData {
	return PageData{
		AppName:       "TERACLONE",
		MockMode:      config.MockMode,
		CurrentPath:   path,
		Title:         title,
		Section:       section,
		Breadcrumbs:   breadcrumbs,
		WorkspaceTabs: workspaceTabs(path, title),
		Menu:          menu(path),
		SubTabs:       subtabs,
		Blocks:        blocks,
	}
}

func ApplyRole(page PageData, role string) PageData {
	page.CurrentRole = strings.ToLower(strings.TrimSpace(role))
	if page.CurrentRole != "port_operator" {
		return page
	}
	allowed := map[string]bool{"대시보드": true, "포트 설정": true, "포트 상태": true}
	filtered := make([]MenuGroup, 0, 3)
	for _, group := range page.Menu {
		if allowed[group.Label] {
			filtered = append(filtered, group)
		}
	}
	page.Menu = filtered
	tabs := page.SubTabs[:0]
	for _, tab := range page.SubTabs {
		if !strings.HasSuffix(tab.Path, "/data-log") {
			tabs = append(tabs, tab)
		}
	}
	page.SubTabs = tabs
	return page
}

func formBlock(title string, action string, fields []FormField, primary string, secondary string) ContentBlock {
	return ContentBlock{
		Kind:  "form",
		Title: title,
		Form: &FormData{
			Action:         "#",
			PrimaryLabel:   primary,
			SecondaryLabel: secondary,
			Fields:         fields,
		},
	}
}

func groupedField(field FormField, group string, hidden bool) FormField {
	field.Group = group
	field.Hidden = hidden
	return field
}

func tableBlock(title string, columns []string, rows []TableRow, primary string, secondary string) ContentBlock {
	return ContentBlock{
		Kind:  "table",
		Title: title,
		Table: &TableData{
			Columns:        columns,
			Rows:           rows,
			EmptyMessage:   "데이터가 없습니다.",
			PrimaryLabel:   primary,
			SecondaryLabel: secondary,
		},
	}
}

func modalBlock(title string, message string, fields []FormField) ContentBlock {
	return ContentBlock{
		Kind:  "modal",
		Title: title,
		Modal: &ModalData{
			Root:    sanitizePath(title),
			Title:   title,
			Message: message,
			Fields:  fields,
			Buttons: []ActionButton{
				{Label: "확인", Action: "confirm-modal", Variant: "primary"},
				{Label: "취소", Action: "cancel-modal", Variant: "secondary"},
			},
		},
	}
}

func userAccountModalBlock() ContentBlock {
	return ContentBlock{
		Kind:  "modal",
		Title: "사용자 추가",
		Modal: &ModalData{
			Root:    "user-create",
			Title:   "사용자 추가",
			Message: "장비의 Local 인증 저장소에 사용자를 추가합니다.",
			Fields: []FormField{
				{Type: "hidden", Name: "id", Value: ""},
				{Label: "사용자 이름", Name: "username", Type: "text", Required: true, Placeholder: "영문 소문자, 숫자, 점, 하이픈, 밑줄", Hint: "최대 64자이며 생성 후에는 변경할 수 없습니다."},
				{Label: "비밀번호", Name: "password", Type: "password", Required: true, Placeholder: "8자 이상 입력", Hint: "수정할 때 비워두면 기존 비밀번호를 유지합니다."},
				{
					Label: "그룹", Name: "group", Type: "select", Required: true, Value: "administrators",
					Options: []Option{
						{Label: "Administrators (관리자)", Value: "administrators", Selected: true},
						{Label: "Port operators (포트 운영자)", Value: "port_operators"},
					},
				},
				{
					Label: "계정 상태", Name: "enabled", Type: "select", Value: "true",
					Options: []Option{{Label: "사용", Value: "true", Selected: true}, {Label: "중지", Value: "false"}},
				},
			},
			Buttons: []ActionButton{
				{Label: "저장", Action: "submit-user-form", Variant: "primary"},
				{Label: "취소", Action: "cancel-modal", Variant: "secondary"},
			},
		},
	}
}

func addressFilterListPage(path string) PageData {
	filterName := "IPv4 필터"
	if strings.Contains(path, "ipv6") {
		filterName = "IPv6 필터"
	}
	if strings.Contains(path, "mac") {
		filterName = "MAC 필터"
	}

	return newPage(path, "관리자 운영", filterName, []string{"관리자 운영", "주소 필터", filterName}, addressFilterTabs(path), []ContentBlock{
		tableBlock(filterName, []string{"규칙 ID", "주소", "프로토콜", "포트", "상태", "관리"}, nil, "규칙 추가", ""),
	})
}

func addressFilterNewPage(path string) PageData {
	title := "IPv4 필터 추가"
	fields := []FormField{
		fixedTextField("규칙 ID", "name", "주소와 프로토콜로 자동 생성"),
		textField("IPv4 주소/CIDR", "address", "192.168.0.0/24", true),
		selectOptionsField("프로토콜", "protocol", "all", protocolOptions()),
		fixedTextField("목적지 포트", "port", "0"),
		toggleField("규칙 사용", "enabled", true),
	}
	if strings.Contains(path, "ipv6") {
		title = "IPv6 필터 추가"
		fields = []FormField{
			fixedTextField("규칙 ID", "name", "주소와 프로토콜로 자동 생성"),
			textField("IPv6 주소/CIDR", "address", "2001:db8::/64", true),
			selectOptionsField("프로토콜", "protocol", "all", protocolOptions()),
			fixedTextField("목적지 포트", "port", "0"),
			toggleField("규칙 사용", "enabled", true),
		}
	}
	if strings.Contains(path, "mac") {
		title = "MAC 필터 추가"
		fields = []FormField{
			fixedTextField("규칙 ID", "name", "주소와 프로토콜로 자동 생성"),
			textField("MAC 주소", "address", "00:11:22:33:44:55", true),
			selectOptionsField("프로토콜", "protocol", "all", protocolOptions()),
			fixedTextField("목적지 포트", "port", "0"),
			toggleField("규칙 사용", "enabled", true),
		}
	}

	return newPage(path, "관리자 운영", title, []string{"관리자 운영", "주소 필터", title}, addressFilterTabs(path), []ContentBlock{formBlock(title, "address-filter-add", fields, "추가", "")})
}

func authServerTabs(path string) []SubTab {
	return []SubTab{{"RADIUS", "/admin/auth/radius", path == "/admin/auth/radius"}, {"TACACS+", "/admin/auth/tacacs", path == "/admin/auth/tacacs"}}
}

func addressFilterTabs(path string) []SubTab {
	return []SubTab{
		{"기본", "/admin/address-filter", path == "/admin/address-filter"},
		{"IPv4", "/admin/address-filter/ipv4", strings.Contains(path, "/ipv4")},
		{"MAC", "/admin/address-filter/mac", strings.Contains(path, "/mac")},
	}
}

func sslTabs(path string) []SubTab {
	return []SubTab{
		{"인증서", "/admin/ssl", path == "/admin/ssl"},
		{"새로 만들기", "/admin/ssl/new", path == "/admin/ssl/new"},
		{"가져오기", "/admin/ssl/import", path == "/admin/ssl/import"},
		{"CSR 내보내기", "/admin/ssl/import-csr", path == "/admin/ssl/import-csr"},
	}
}

func backupTabs(path string) []SubTab {
	return []SubTab{{"내보내기", "/admin/backup/export", path == "/admin/backup/export"}, {"복원", "/admin/backup/restore", path != "/admin/backup/export"}}
}

func alertTabs(path string) []SubTab {
	return []SubTab{
		{"시스템 이벤트", "/settings/alert/event", path == "/settings/alert/event"},
		{"시리얼 이벤트", "/settings/alert/serial-event", path == "/settings/alert/serial-event"},
		{"메일", "/settings/alert/mail", path == "/settings/alert/mail"},
		{"SNMP Trap", "/settings/alert/snmp-trap-filter", path == "/settings/alert/snmp-trap-filter"},
	}
}

func roleOptions() []Option {
	return []Option{{Label: "포트 운영자", Value: "port_operator", Selected: true}, {Label: "관리자", Value: "administrator"}}
}

func protocolOptions() []Option {
	return []Option{{Label: "전체", Value: "all", Selected: true}, {Label: "HTTP", Value: "http"}, {Label: "HTTPS", Value: "https"}, {Label: "SSH", Value: "ssh"}, {Label: "Telnet", Value: "telnet"}}
}

func channelSelectOptions() []Option {
	options := make([]Option, 0, 48)
	for channel := 1; channel <= 48; channel++ {
		value := fmt.Sprintf("CH%02d", channel)
		options = append(options, Option{Label: value, Value: value, Selected: channel == 1})
	}
	return options
}

func workspaceTabs(path string, title string) []WorkspaceTab {
	return []WorkspaceTab{
		{Key: tabKeyForPath(path), Label: tabLabelForPath(path, title), Path: path, Active: true},
	}
}

func menu(path string) []MenuGroup {
	groups := []MenuGroup{
		{Label: "대시보드", Icon: "DB", Path: "/"},
		{Label: "네트워크 설정", Icon: "NW", Path: "/network/interface-1"},
		{Label: "포트 설정", Icon: "PT", Path: "/ports/1/parameters"},
		{Label: "직접 연결 모드", Icon: "DG", Path: "/port-debug"},
		{Label: "관리자 운영", Icon: "AD", Path: "/admin/users"},
		{Label: "기타 설정", Icon: "ST", Path: "/settings/alert/event"},
		{Label: "로그", Icon: "LG", Path: "/logs/system"},
		{Label: "포트 상태", Icon: "PS", Path: "/port-status"},
		{Label: "공장 초기화", Icon: "FR", Path: "/device/factory-reset"},
	}

	for i := range groups {
		if groups[i].Path == "/" {
			groups[i].Active = path == "/"
			continue
		}
		groups[i].Active = path == groups[i].Path || strings.HasPrefix(path, trimMenuRoot(groups[i].Path))
	}

	for i := range groups {
		switch groups[i].Label {
		case "포트 설정":
			groups[i].Expanded = false
		case "관리자 운영":
			groups[i].Expanded = strings.HasPrefix(path, "/admin/") || strings.HasPrefix(path, "/tools/nettest/")
			groups[i].Active = groups[i].Expanded
			groups[i].Children = append(groups[i].Children,
				MenuChild{"사용자 계정", "/admin/users", strings.HasPrefix(path, "/admin/users")},
				MenuChild{"인증 서버", "/admin/auth/radius", strings.HasPrefix(path, "/admin/auth/")},
				MenuChild{"주소 필터", "/admin/address-filter", strings.HasPrefix(path, "/admin/address-filter")},
				MenuChild{"SNMP", "/admin/snmp", path == "/admin/snmp"},
				MenuChild{"SSL 인증서", "/admin/ssl", strings.HasPrefix(path, "/admin/ssl")},
				MenuChild{"백업/복원", "/admin/backup/export", strings.HasPrefix(path, "/admin/backup/")},
				MenuChild{"펌웨어", "/admin/firmware", path == "/admin/firmware"},
				MenuChild{"진단 도구", "/tools/nettest/ping", strings.HasPrefix(path, "/tools/nettest/")},
			)
		case "기타 설정":
			groups[i].Expanded = strings.HasPrefix(path, "/settings/")
			groups[i].Children = append(groups[i].Children,
				MenuChild{"알림 설정", "/settings/alert/event", strings.HasPrefix(path, "/settings/alert/")},
				MenuChild{"시스템 로그", "/settings/system-log/remote", strings.HasPrefix(path, "/settings/system-log/")},
				MenuChild{"날짜와 시간", "/settings/datetime", path == "/settings/datetime"},
			)
		case "로그":
			groups[i].Expanded = strings.HasPrefix(path, "/logs/")
			groups[i].Children = append(groups[i].Children,
				MenuChild{"시스템 로그", "/logs/system", path == "/logs/system"},
				MenuChild{"포트 로그", "/logs/ports", path == "/logs/ports"},
				MenuChild{"포트 상태 이벤트", "/logs/links", path == "/logs/links"},
			)
		}
	}

	return groups
}

func portLinks() []PortLink {
	links := make([]PortLink, 0, 48)
	for i := 1; i <= 48; i++ {
		links = append(links, PortLink{
			Number: i,
			// The real state is populated by /api/v1/ports. Rendering guessed
			// values here causes a visible false-UP flash during page changes.
			Up:    false,
			Blink: false,
		})
	}
	return links
}

func portTargets(selected int) []PortTarget {
	targets := make([]PortTarget, 0, 48)
	for i := 1; i <= 48; i++ {
		targets = append(targets, PortTarget{
			Number:  i,
			Checked: i == selected,
		})
	}
	return targets
}

func textField(label string, name string, value string, required bool) FormField {
	return FormField{Label: label, Name: name, Type: "text", Value: value, Required: required}
}

func shortcutField(label, name, value, hint string) FormField {
	// Shortcut values remain in the form so the integration layer can preserve
	// the running configuration, but they are intentionally not user-facing.
	return FormField{Label: label, Name: name, Type: "text", Value: value, Hidden: true}
}

func numberField(label string, name string, value string, required bool) FormField {
	return boundedNumberField(label, name, value, required, "1", "20")
}

func boundedNumberField(label string, name string, value string, required bool, min string, max string) FormField {
	return FormField{Label: label, Name: name, Type: "number", Value: value, Required: required, Min: min, Max: max}
}

func fixedTextField(label string, name string, value string) FormField {
	return FormField{Label: label, Name: name, Type: "text", Value: value, Disabled: true, Fixed: true}
}

func passwordField(label string, name string, value string) FormField {
	return FormField{Label: label, Name: name, Type: "password", Placeholder: value}
}

func fileField(label string, name string, accept string, required bool) FormField {
	return FormField{Label: label, Name: name, Type: "file", Accept: accept, Required: required}
}

func textAreaField(label string, name string, value string, rows int) FormField {
	return FormField{Label: label, Name: name, Type: "textarea", Value: value, Rows: rows}
}

func toggleField(label string, name string, checked bool) FormField {
	return FormField{Label: label, Name: name, Type: "toggle", Checked: checked}
}

func selectField(label string, name string, value string, options []string) FormField {
	field := FormField{Label: label, Name: name, Type: "select", Value: value}
	for _, option := range options {
		field.Options = append(field.Options, Option{
			Label:    option,
			Value:    option,
			Selected: option == value,
		})
	}
	return field
}

func selectOptionsField(label string, name string, value string, options []Option) FormField {
	field := FormField{Label: label, Name: name, Type: "select", Value: value}
	for _, option := range options {
		option.Selected = option.Value == value
		field.Options = append(field.Options, option)
	}
	return field
}

func portModeField(value string) FormField {
	return selectOptionsField("동작 모드", "mode", value, []Option{
		{Label: "사용 안 함", Value: "disabled"},
		{Label: "Reverse SSH", Value: "reverse_ssh"},
		{Label: "Reverse Telnet", Value: "reverse_telnet"},
	})
}

func authenticationField() FormField {
	return selectOptionsField("인증 방식", "authentication", "local", []Option{
		{Label: "Local", Value: "local"},
		{Label: "RADIUS", Value: "radius"},
		{Label: "TACACS", Value: "tacacs"},
	})
}

func sanitizePath(path string) string {
	return strings.NewReplacer("/", "-", ":", "-", "_", "-").Replace(strings.Trim(path, "/"))
}

func trimMenuRoot(path string) string {
	if path == "/" {
		return "/"
	}
	parts := strings.Split(strings.Trim(path, "/"), "/")
	if len(parts) == 0 {
		return "/"
	}
	return "/" + parts[0] + "/"
}

func shortLabelForPath(path string) string {
	switch {
	case strings.HasPrefix(path, "/network/"):
		return "네트워크 설정"
	case strings.HasPrefix(path, "/ports/"):
		return "포트 설정"
	case strings.HasPrefix(path, "/admin/"):
		return "관리자 운영"
	case strings.HasPrefix(path, "/settings/"):
		return "기타 설정"
	case strings.HasPrefix(path, "/tools/"):
		return "진단 도구"
	case strings.HasPrefix(path, "/logs/"):
		return "로그"
	default:
		return "장비 화면"
	}
}

func tabLabelForPath(path string, title string) string {
	switch {
	case path == "/":
		return "대시보드"
	case strings.HasPrefix(path, "/ports/"):
		parts := strings.Split(strings.Trim(path, "/"), "/")
		if len(parts) >= 2 {
			if portID, err := strconv.Atoi(parts[1]); err == nil {
				return fmt.Sprintf("포트 %d 설정", portID)
			}
		}
	case strings.HasPrefix(path, "/admin/snmp"):
		return "SNMP"
	case strings.HasPrefix(path, "/tools/nettest/"):
		return "네트워크 테스트"
	}

	if title != "" {
		return title
	}

	return shortLabelForPath(path)
}

func tabKeyForPath(path string) string {
	switch {
	case path == "/":
		return "dashboard"
	case strings.HasPrefix(path, "/network/"):
		return "network"
	case strings.HasPrefix(path, "/ports/"):
		return "port-settings"
	case strings.HasPrefix(path, "/port-debug"):
		return "port-debug"
	case strings.HasPrefix(path, "/admin/snmp"):
		return "admin-snmp"
	case strings.HasPrefix(path, "/admin/"):
		return "admin"
	case strings.HasPrefix(path, "/settings/"):
		return "settings"
	case strings.HasPrefix(path, "/tools/nettest/"):
		return "network-test"
	case strings.HasPrefix(path, "/tools/"):
		return "tools"
	case strings.HasPrefix(path, "/logs/"):
		return "logs"
	case path == "/port-status":
		return "port-status"
	case path == "/password":
		return "password"
	case path == "/config/save":
		return "config-save"
	case path == "/ports/restart":
		return "ports-restart"
	case path == "/device/restart":
		return "device-restart"
	default:
		return strings.Trim(strings.ReplaceAll(path, "/", "-"), "-")
	}
}