"""
Dell iDRAC REDFISH API 클라이언트
Dell 서버 펌웨어 조회 최적화 버전
"""

import requests
import json
import time
from urllib3.exceptions import InsecureRequestWarning
from requests.auth import HTTPBasicAuth

# SSL 경고 비활성화
requests.packages.urllib3.disable_warnings(category=InsecureRequestWarning)


class DellRedfishClient:
    def __init__(self, idrac_ip, username, password):
        """
        Dell iDRAC REDFISH 클라이언트 초기화
        
        Args:
            idrac_ip: iDRAC IP 주소
            username: iDRAC 사용자명
            password: iDRAC 비밀번호
        """
        self.idrac_ip = idrac_ip
        self.base_url = f"https://{idrac_ip}"
        self.auth = HTTPBasicAuth(username, password)
        self.headers = {'Content-Type': 'application/json'}
        self.session = requests.Session()
        self.session.verify = False
        self.session.auth = self.auth
        
    def check_connection(self):
        """iDRAC 연결 확인"""
        try:
            url = f"{self.base_url}/redfish/v1"
            response = self.session.get(url, timeout=10)
            return response.status_code == 200
        except Exception as e:
            print(f"연결 오류: {str(e)}")
            return False
    
    def get_firmware_inventory(self):
        """
        현재 설치된 펌웨어 목록 조회 (Dell 최적화)
        주요 컴포넌트만 필터링하여 반환
        """
        try:
            url = f"{self.base_url}/redfish/v1/UpdateService/FirmwareInventory"
            response = self.session.get(url, timeout=30)
            
            if response.status_code != 200:
                print(f"펌웨어 목록 조회 실패: {response.status_code}")
                return []
            
            data = response.json()
            inventory = []
            
            # 주요 컴포넌트 타입 (Dell 서버)
            important_components = [
                'BIOS', 'iDRAC', 'CPLD', 'Diagnostics',
                'Driver', 'Firmware', 'USC', 'NIC',
                'RAID', 'PERC', 'Storage', 'Backplane',
                'HBA', 'Network', 'Intel', 'Broadcom',
                'Mellanox', 'Emulex', 'QLogic'
            ]
            
            # 로그 간소화: 전체 펌웨어 항목 수 출력 제거
            
            # 각 펌웨어 항목 조회
            for idx, member in enumerate(data.get('Members', [])):
                try:
                    fw_url = f"{self.base_url}{member.get('@odata.id', '')}"
                    fw_response = self.session.get(fw_url, timeout=10)
                    
                    if fw_response.status_code == 200:
                        fw_data = fw_response.json()
                        
                        # 이름과 버전 추출 (여러 필드 시도)
                        name = (fw_data.get('Name') or 
                               fw_data.get('SoftwareId') or 
                               fw_data.get('Id') or 
                               'Unknown')
                        
                        version = (fw_data.get('Version') or 
                                  fw_data.get('VersionString') or 
                                  'Unknown')
                        
                        # 컴포넌트 타입 확인
                        component_type = fw_data.get('ComponentType', '')
                        
                        # 중요 컴포넌트만 필터링
                        is_important = any(comp.lower() in name.lower() 
                                          for comp in important_components)
                        
                        if is_important or component_type:
                            item = {
                                'Name': name,
                                'Version': version,
                                'ComponentType': component_type,
                                'Updateable': fw_data.get('Updateable', False),
                                'Status': fw_data.get('Status', {}).get('Health', 'OK'),
                                'Id': fw_data.get('Id', ''),
                                'Description': fw_data.get('Description', ''),
                                'ReleaseDate': fw_data.get('ReleaseDate', '')
                            }
                            
                            inventory.append(item)
                            
                            # 진행 상황 출력
                            if (idx + 1) % 10 == 0:
                                pass  # 로그 간소화: 진행률 출력 제거
                    
                except Exception as e:
                    print(f"펌웨어 항목 조회 오류 ({idx}): {str(e)}")
                    continue
            
            # 이름순 정렬
            inventory.sort(key=lambda x: x['Name'])
            
            # 로그 간소화: 중요 펌웨어 항목 수 출력 제거
            
            # 주요 컴포넌트 요약
            bios = next((x for x in inventory if 'BIOS' in x['Name']), None)
            idrac = next((x for x in inventory if 'iDRAC' in x['Name']), None)
            
            if bios:
                pass  # 로그 간소화: BIOS 버전 출력 제거
            if idrac:
                pass  # 로그 간소화: iDRAC 버전 출력 제거
            
            return inventory
            
        except Exception as e:
            print(f"펌웨어 목록 조회 오류: {str(e)}")
            import traceback
            traceback.print_exc()
            return []
    
    def get_firmware_summary(self):
        """
        주요 펌웨어 버전만 간단히 조회
        BIOS, iDRAC, PERC 등 핵심 컴포넌트만
        """
        try:
            inventory = self.get_firmware_inventory()
            
            summary = {
                'BIOS': 'N/A',
                'iDRAC': 'N/A',
                'PERC': 'N/A',
                'NIC': 'N/A',
                'CPLD': 'N/A'
            }
            
            for item in inventory:
                name = item['Name']
                version = item['Version']
                
                if 'BIOS' in name:
                    summary['BIOS'] = version
                elif 'iDRAC' in name or 'Integrated Dell Remote Access' in name:
                    summary['iDRAC'] = version
                elif 'PERC' in name or 'RAID' in name:
                    if summary['PERC'] == 'N/A':
                        summary['PERC'] = version
                elif 'NIC' in name or 'Network' in name:
                    if summary['NIC'] == 'N/A':
                        summary['NIC'] = version
                elif 'CPLD' in name:
                    summary['CPLD'] = version
            
            return summary
            
        except Exception as e:
            print(f"펌웨어 요약 조회 오류: {str(e)}")
            return {}
    
    def upload_firmware_staged(self, dup_file_path):
        """
        DUP 파일을 iDRAC에 업로드 (스테이징만, 재부팅 시 적용)
        
        Args:
            dup_file_path: 업로드할 DUP 파일 경로
            
        Returns:
            dict: {'success': bool, 'job_id': str, 'message': str}
        """
        import os
        if not os.path.exists(dup_file_path):
            return {
                'success': False,
                'job_id': None,
                'message': f'파일을 찾을 수 없습니다: {dup_file_path}'
            }
        
        file_name = os.path.basename(dup_file_path)
        file_size = os.path.getsize(dup_file_path)
        
        print(f"파일 업로드: {file_name} ({file_size / (1024*1024):.2f} MB)")
        
        try:
            url = f"{self.base_url}/redfish/v1/UpdateService/MultipartUpload"
            
            # Multipart 업로드 준비
            with open(dup_file_path, 'rb') as f:
                files = {
                    'file': (file_name, f, 'application/octet-stream')
                }
                
                # targets=INSTALLED 파라미터로 스테이징 모드 설정
                data = {
                    '@Redfish.OperationApplyTime': 'OnReset',
                    'Targets': []
                }
                
                multipart_data = {
                    'UpdateParameters': (None, json.dumps(data), 'application/json')
                }
                multipart_data.update(files)
                
                print("업로드 시작...")
                response = self.session.post(
                    url,
                    files=multipart_data,
                    auth=self.auth,
                    verify=False,
                    timeout=600  # 10분 타임아웃
                )
                
                print(f"응답 코드: {response.status_code}")
                
                if response.status_code in [200, 201, 202]:
                    response_data = response.json()
                    
                    # Task 또는 Job ID 추출
                    task_id = None
                    if '@odata.id' in response_data:
                        task_id = response_data['@odata.id'].split('/')[-1]
                    elif 'Id' in response_data:
                        task_id = response_data['Id']
                    
                    # Location 헤더에서 Job ID 추출
                    location = response.headers.get('Location', '')
                    if location and not task_id:
                        task_id = location.split('/')[-1]
                    
                    print(f"업로드 완료! Task/Job ID: {task_id}")
                    
                    return {
                        'success': True,
                        'job_id': task_id or 'STAGED',
                        'message': '업로드 완료 (재부팅 시 적용)'
                    }
                else:
                    error_msg = response.text
                    print(f"업로드 실패: {error_msg}")
                    return {
                        'success': False,
                        'job_id': None,
                        'message': f'업로드 실패 (코드: {response.status_code})'
                    }
                    
        except Exception as e:
            print(f"업로드 오류: {str(e)}")
            import traceback
            traceback.print_exc()
            return {
                'success': False,
                'job_id': None,
                'message': f'업로드 오류: {str(e)}'
            }
    
    def get_job_queue(self):
        """Job Queue 조회"""
        try:
            url = f"{self.base_url}/redfish/v1/Managers/iDRAC.Embedded.1/Jobs"
            response = self.session.get(url, timeout=30)
            
            if response.status_code == 200:
                data = response.json()
                jobs = []
                
                for member in data.get('Members', [])[:20]:  # 최근 20개
                    job_url = f"{self.base_url}{member['@odata.id']}"
                    job_response = self.session.get(job_url, timeout=10)
                    
                    if job_response.status_code == 200:
                        job_data = job_response.json()
                        jobs.append({
                            'Id': job_data.get('Id', ''),
                            'Name': job_data.get('Name', ''),
                            'JobState': job_data.get('JobState', 'Unknown'),
                            'PercentComplete': job_data.get('PercentComplete', 0),
                            'Message': job_data.get('Message', ''),
                            'StartTime': job_data.get('StartTime', ''),
                            'EndTime': job_data.get('EndTime', '')
                        })
                
                return jobs
            else:
                return []
                
        except Exception as e:
            print(f"Job Queue 조회 오류: {str(e)}")
            return []
    
    def get_job_status(self, job_id):
        """특정 Job 상태 조회"""
        try:
            url = f"{self.base_url}/redfish/v1/Managers/iDRAC.Embedded.1/Jobs/{job_id}"
            response = self.session.get(url, timeout=10)
            
            if response.status_code == 200:
                data = response.json()
                return {
                    'Id': data.get('Id', ''),
                    'Name': data.get('Name', ''),
                    'JobState': data.get('JobState', 'Unknown'),
                    'PercentComplete': data.get('PercentComplete', 0),
                    'Message': data.get('Message', ''),
                    'StartTime': data.get('StartTime', ''),
                    'EndTime': data.get('EndTime', '')
                }
            else:
                return None
                
        except Exception as e:
            print(f"Job 상태 조회 오류: {str(e)}")
            return None
    
    def delete_job(self, job_id):
        """Job 삭제"""
        try:
            url = f"{self.base_url}/redfish/v1/Managers/iDRAC.Embedded.1/Jobs/{job_id}"
            response = self.session.delete(url, timeout=10)
            return response.status_code in [200, 204]
        except Exception as e:
            print(f"Job 삭제 오류: {str(e)}")
            return False
    
    def get_power_status(self):
        """서버 전원 상태 조회"""
        try:
            url = f"{self.base_url}/redfish/v1/Systems/System.Embedded.1"
            response = self.session.get(url, timeout=10)
            
            if response.status_code == 200:
                data = response.json()
                return {
                    'PowerState': data.get('PowerState', 'Unknown'),
                    'Status': data.get('Status', {}).get('Health', 'Unknown')
                }
            else:
                return {'PowerState': 'Unknown', 'Status': 'Unknown'}
                
        except Exception as e:
            print(f"전원 상태 조회 오류: {str(e)}")
            return {'PowerState': 'Unknown', 'Status': 'Unknown'}
    
    def reboot_server(self, reset_type='GracefulRestart'):
        """
        서버 재부팅
        
        Args:
            reset_type: GracefulRestart, ForceRestart, GracefulShutdown, ForceOff, On
        """
        try:
            url = f"{self.base_url}/redfish/v1/Systems/System.Embedded.1/Actions/ComputerSystem.Reset"
            payload = {'ResetType': reset_type}
            
            response = self.session.post(
                url,
                data=json.dumps(payload),
                headers=self.headers,
                timeout=30
            )
            
            return response.status_code in [200, 202, 204]
            
        except Exception as e:
            print(f"재부팅 오류: {str(e)}")
            return False
    
    def power_on_server(self):
        """서버 전원 켜기"""
        return self.reboot_server('On')
    
    def power_off_server(self, shutdown_type='GracefulShutdown'):
        """
        서버 전원 끄기
        
        Args:
            shutdown_type: GracefulShutdown 또는 ForceOff
        """
        return self.reboot_server(shutdown_type)

    def get_bios_attributes_all(self):
        """
        설정된 모든 BIOS 속성 조회
        
        Returns:
            dict: {AttributeName: Value, ...}
        """
        try:
            # 1. BIOS 리소스 조회
            url = f"{self.base_url}/redfish/v1/Systems/System.Embedded.1/Bios"
            response = self.session.get(url, timeout=15)
            
            if response.status_code == 200:
                data = response.json()
                
                # Attributes가 바로 있는 경우 (표준)
                if 'Attributes' in data:
                    return data['Attributes']
                
                # Future: Attributes가 별도 링크인 경우 처리 필요할 수 있음
                return {}
            else:
                print(f"BIOS 속성 조회 실패: {response.status_code}")
                return {}
                
        except Exception as e:
            print(f"BIOS 속성 조회 오류: {str(e)}")
            return {}

    def get_bios_attribute_registry(self):
        """
        BIOS Attribute Registry를 조회하여 속성 이름(AttributeName)과 
        사용자 친화적인 이름(DisplayName)의 매핑 정보를 반환합니다.
        
        Returns:
            dict: {AttributeName: DisplayName, ...}
        """
        try:
            # 1. BIOS 리소스에서 AttributeRegistry 정보 확인
            url = f"{self.base_url}/redfish/v1/Systems/System.Embedded.1/Bios"
            response = self.session.get(url, timeout=15)
            
            if response.status_code != 200:
                print("BIOS 리소스 조회 실패")
                return {}
            
            data = response.json()
            registry_name = data.get('AttributeRegistry')
            
            if not registry_name:
                print("BIOS Attribute Registry 정보를 찾을 수 없음. 기본값으로 시도합니다.")
                registry_name = "BiosAttributeRegistry"
            
            print(f"DEBUG: Looking for BIOS Registry: {registry_name}")
                
            # 2. Registries 컬렉션에서 해당 레지스트리 찾기
            reg_url = f"{self.base_url}/redfish/v1/Registries"
            reg_res = self.session.get(reg_url, timeout=10)
            
            target_location = None
            
            if reg_res.status_code == 200:
                reg_data = reg_res.json()
                
                # 검색할 이름 후보군 (버전 제거 등)
                search_candidates = [registry_name]
                if '.' in registry_name:
                    search_candidates.append(registry_name.split('.')[0])
                
                # 'BiosAttributeRegistry'가 없다면 추가 (하드코딩 폴백)
                if 'BiosAttributeRegistry' not in search_candidates:
                    search_candidates.append('BiosAttributeRegistry')
                
                print(f"DEBUG: Registry Candidates: {search_candidates}")

                for member in reg_data.get('Members', []):
                    m_url = member.get('@odata.id', '')
                    
                    # URL 끝부분(ID) 추출
                    # /redfish/v1/Registries/BiosAttributeRegistry
                    m_id = m_url.rstrip('/').split('/')[-1]
                    
                    match_found = False
                    for candidate in search_candidates:
                        if candidate.lower() in m_id.lower():
                             match_found = True
                             break
                    
                    if match_found:
                        print(f"DEBUG: Found Registry Match: {m_url}")
                        # 레지스트리 상세 조회
                        detail_url = f"{self.base_url}{m_url}"
                        detail_res = self.session.get(detail_url, timeout=10)
                        if detail_res.status_code == 200:
                            detail_data = detail_res.json()
                            # Location 정보 찾기
                            locations = detail_data.get('Location', [])
                            for loc in locations:
                                if loc.get('Language', '').startswith('en'):
                                    target_location = loc.get('Uri')
                                    break
                            if not target_location and locations:
                                target_location = locations[0].get('Uri')
                        
                        if target_location:
                            break
            
            # 3. Registry 파일(JSON) 다운로드 및 파싱
            if target_location:
                # URI가 전체 경로가 아닐 수 있음
                if not target_location.startswith('http'):
                     final_url = f"{self.base_url}{target_location}"
                else:
                     final_url = target_location
                     
                print(f"Downloading BIOS Registry from: {final_url}")
                file_res = self.session.get(final_url, timeout=30)
                
                if file_res.status_code == 200:
                    reg_json = file_res.json()
                    mapping = {}
                    
                    # RegistryEntries 파싱
                    # 구조: { "RegistryEntries": { "Attributes": [ ... ] } }  또는 바로 Attributes
                    attributes = []
                    if 'RegistryEntries' in reg_json:
                        if 'Attributes' in reg_json['RegistryEntries']:
                            attributes = reg_json['RegistryEntries']['Attributes']
                        else:
                            # 썸네일 등 다른 구조일 수 있음, 여기서는 일반적 구조 따름
                            pass
                    elif 'Attributes' in reg_json:
                         attributes = reg_json['Attributes']
                    
                    for entry in attributes:
                        attr_name = entry.get('AttributeName')
                        display_name = entry.get('DisplayName')
                        if attr_name and display_name:
                            mapping[attr_name] = display_name
                            
                    print(f"BIOS Registry 파싱 완료: {len(mapping)}개 항목")
                    return mapping
            
            print(f"BIOS Registry 위치를 찾을 수 없음 (TargetLocation: {target_location})")
            return {}
            
        except Exception as e:
            print(f"BIOS Attribute Registry 조회 오류: {str(e)}")
            import traceback
            traceback.print_exc()
            return {}


    def _flatten_dict(self, d, parent_key='', sep='.'):
        """중첩된 딕셔너리를 평탄화 (Nested JSON -> Flat JSON)"""
        items = []
        for k, v in d.items():
            new_key = f"{parent_key}{sep}{k}" if parent_key else k
            if isinstance(v, dict):
                items.extend(self._flatten_dict(v, new_key, sep=sep).items())
            elif isinstance(v, list):
                # 리스트인 경우 인덱스를 붙여서 평탄화
                for i, item in enumerate(v):
                    if isinstance(item, dict):
                         items.extend(self._flatten_dict(item, f"{new_key}{sep}{i}", sep=sep).items())
                    else:
                        items.append((f"{new_key}{sep}{i}", item))
            else:
                items.append((new_key, v))
        return dict(items)

    def get_idrac_attributes_all(self):
        """
        설정된 모든 iDRAC 속성 조회 (Attributes + NetworkProtocol + AccountService)
        
        Returns:
            dict: {AttributeName: Value, ...} (Flattened)
        """
        all_attributes = {}
        
        try:
            # 1. 기본 Attributes 조회
            url = f"{self.base_url}/redfish/v1/Managers/iDRAC.Embedded.1/Attributes"
            response = self.session.get(url, timeout=15)
            
            if response.status_code == 200:
                data = response.json()
                attrs = data.get('Attributes', data)
                # @odata 필드 제거
                attrs = {k: v for k, v in attrs.items() if not k.startswith('@odata')}
                all_attributes.update(attrs)
            
            # 2. Network Protocol 조회 (NTP, SNMP, IPMI, SSH 등)
            net_url = f"{self.base_url}/redfish/v1/Managers/iDRAC.Embedded.1/NetworkProtocol"
            net_res = self.session.get(net_url, timeout=10)
            if net_res.status_code == 200:
                net_data = net_res.json()
                # 불필요한 필드 제거
                exclude_keys = ['@odata.context', '@odata.id', '@odata.type', 'Name', 'Description', 'Id', 'Status']
                filtered_net = {k: v for k, v in net_data.items() if k not in exclude_keys}
                
                # 평탄화하여 병합 (Prefix: NetworkProtocol)
                flat_net = self._flatten_dict(filtered_net, parent_key='NetworkProtocol')
                all_attributes.update(flat_net)
                
            # 3. Account Service 조회 (LDAP, ActiveDirectory)
            # /redfish/v1/AccountService
            acc_url = f"{self.base_url}/redfish/v1/AccountService"
            acc_res = self.session.get(acc_url, timeout=10)
            if acc_res.status_code == 200:
                acc_data = acc_res.json()
                exclude_keys = ['@odata.context', '@odata.id', '@odata.type', 'Name', 'Description', 'Id', 'Status', 'Roles', 'Accounts']
                filtered_acc = {k: v for k, v in acc_data.items() if k not in exclude_keys}
                
                flat_acc = self._flatten_dict(filtered_acc, parent_key='AccountService')
                all_attributes.update(flat_acc)
            
            return all_attributes
                
            return all_attributes
                
        except Exception as e:
            print(f"iDRAC 속성 조회 오류: {str(e)}")
            return all_attributes or {}

    def get_idrac_attribute_registry(self):
        """
        iDRAC Attribute Registry를 조회하여 속성 이름(AttributeName)과 
        사용자 친화적인 이름(DisplayName)의 매핑 정보를 반환합니다.
        
        Returns:
            dict: {AttributeName: DisplayName, ...}
        """
        try:
            # 1. iDRAC 리소스에서 AttributeRegistry 정보 확인
            url = f"{self.base_url}/redfish/v1/Managers/iDRAC.Embedded.1/Attributes"
            response = self.session.get(url, timeout=15)
            
            if response.status_code != 200:
                print("iDRAC 리소스 조회 실패")
                return {}
            
            data = response.json()
            registry_name = data.get('AttributeRegistry')
            
            if not registry_name:
                print("iDRAC Attribute Registry 정보를 찾을 수 없음. 기본값으로 시도합니다.")
                # iDRAC의 경우 보통 'iDRACRegistry' 또는 'IdracAttributeRegistry' 등일 수 있음
                # 하지만 대부분의 Redfish 구현체에서 AttributeRegistry 프로퍼티가 있거나 
                # Registries 컬렉션에서 찾을 수 있습니다.
                registry_name = "iDRACAttributeRegistry"
            
            print(f"DEBUG: Looking for iDRAC Registry: {registry_name}")
                
            # 2. Registries 컬렉션에서 해당 레지스트리 찾기
            reg_url = f"{self.base_url}/redfish/v1/Registries"
            reg_res = self.session.get(reg_url, timeout=10)
            
            target_location = None
            
            if reg_res.status_code == 200:
                reg_data = reg_res.json()
                
                # 검색할 이름 후보군 (버전 제거 등)
                search_candidates = [registry_name]
                if '.' in registry_name:
                    search_candidates.append(registry_name.split('.')[0])
                
                # 'iDRACAttributeRegistry'가 없다면 추가 (하드코딩 폴백)
                if 'iDRACAttributeRegistry' not in search_candidates:
                    search_candidates.append('iDRACAttributeRegistry')
                if 'iDRACRegistry' not in search_candidates:
                    search_candidates.append('iDRACRegistry')
                
                print(f"DEBUG: iDRAC Registry Candidates: {search_candidates}")

                for member in reg_data.get('Members', []):
                    m_url = member.get('@odata.id', '')
                    m_id = m_url.rstrip('/').split('/')[-1]
                    
                    match_found = False
                    for candidate in search_candidates:
                        if candidate.lower() in m_id.lower():
                             match_found = True
                             break
                    
                    if match_found:
                        print(f"DEBUG: Found iDRAC Registry Match: {m_url}")
                        # 레지스트리 상세 조회
                        detail_url = f"{self.base_url}{m_url}"
                        detail_res = self.session.get(detail_url, timeout=10)
                        if detail_res.status_code == 200:
                            detail_data = detail_res.json()
                            # Location 정보 찾기 (영어 버전 선호)
                            locations = detail_data.get('Location', [])
                            for loc in locations:
                                if loc.get('Language', '').startswith('en'):
                                    target_location = loc.get('Uri')
                                    break
                            if not target_location and locations:
                                target_location = locations[0].get('Uri')
                        
                        if target_location:
                            break
            
            # 3. Registry 파일(JSON) 다운로드 및 파싱
            if target_location:
                # URI가 전체 경로가 아닐 수 있음
                if not target_location.startswith('http'):
                     final_url = f"{self.base_url}{target_location}"
                else:
                     final_url = target_location
                     
                print(f"Downloading iDRAC Registry from: {final_url}")
                file_res = self.session.get(final_url, timeout=30)
                
                if file_res.status_code == 200:
                    reg_json = file_res.json()
                    mapping = {}
                    
                    # RegistryEntries 파싱
                    attributes = []
                    if 'RegistryEntries' in reg_json:
                        if 'Attributes' in reg_json['RegistryEntries']:
                            attributes = reg_json['RegistryEntries']['Attributes']
                        else:
                            pass
                    elif 'Attributes' in reg_json:
                         attributes = reg_json['Attributes']
                    
                    for entry in attributes:
                        attr_name = entry.get('AttributeName')
                        display_name = entry.get('DisplayName')
                        if attr_name and display_name:
                            mapping[attr_name] = display_name
                            
                    print(f"iDRAC Registry 파싱 완료: {len(mapping)}개 항목")
                    return mapping
            
            print(f"iDRAC Registry 위치를 찾을 수 없음 (TargetLocation: {target_location})")
            return {}
            
        except Exception as e:
            print(f"iDRAC Attribute Registry 조회 오류: {str(e)}")
            return {}

    def get_system_info_detailed(self):
        """
        시스템 상세 정보 (CPU, Memory, Model 등) 조회
        """
        try:
            url = f"{self.base_url}/redfish/v1/Systems/System.Embedded.1"
            response = self.session.get(url, timeout=15)
            
            if response.status_code != 200:
                return None
                
            data = response.json()
            
            info = {
                'Model': data.get('Model', 'Unknown'),
                'Manufacturer': data.get('Manufacturer', 'Unknown'),
                'SerialNumber': data.get('SerialNumber', 'Unknown'),
                'PowerState': data.get('PowerState', 'Unknown'),
                'BiosVersion': data.get('BiosVersion', 'Unknown'),
                'ProcessorSummary': {
                    'Count': data.get('ProcessorSummary', {}).get('Count', 0),
                    'Model': data.get('ProcessorSummary', {}).get('Model', 'Unknown'),
                    'Status': data.get('ProcessorSummary', {}).get('Status', {}).get('Health', 'Unknown')
                },
                'MemorySummary': {
                    'TotalSystemMemoryGiB': data.get('MemorySummary', {}).get('TotalSystemMemoryGiB', 0),
                    'Status': data.get('MemorySummary', {}).get('Status', {}).get('Health', 'Unknown')
                },
                'HostName': data.get('HostName', '')
            }
            return info
            
        except Exception as e:
            print(f"시스템 상세 조회 오류: {str(e)}")
            return None

    def get_storage_configuration(self):
        """
        RAID 컨트롤러 및 스토리지 구성 정보 조회
        Controllers, Volumes(RAID), Drives 정보 포함
        """
        try:
            url = f"{self.base_url}/redfish/v1/Systems/System.Embedded.1/Storage"
            response = self.session.get(url, timeout=20)
            
            if response.status_code != 200:
                print(f"스토리지 조회 실패: {response.status_code}")
                return {'Controllers': []}
            
            data = response.json()
            controllers = []
            
            for member in data.get('Members', []):
                try:
                    ctrl_url = f"{self.base_url}{member['@odata.id']}"
                    ctrl_res = self.session.get(ctrl_url, timeout=10)
                    
                    if ctrl_res.status_code != 200:
                        continue
                        
                    ctrl_data = ctrl_res.json()
                    
                    # 1. 컨트롤러 기본 정보
                    controller = {
                        'Name': ctrl_data.get('Name', 'Unknown'),
                        'Id': ctrl_data.get('Id', ''),
                        'Model': ctrl_data.get('Model', ''),
                        'FirmwareVersion': '', # 아래에서 찾음
                        'Status': ctrl_data.get('Status', {}).get('Health', 'Unknown'),
                        'Volumes': [],
                        'Drives': []
                    }
                    
                    # 펌웨어 버전 찾기 (Controllers 리스트 내)
                    for c in ctrl_data.get('Controllers', []):
                        if 'FirmwareVersion' in c:
                            controller['FirmwareVersion'] = c['FirmwareVersion']
                            break
                    
                    # 2. Volumes (Virtual Disks)
                    # Volumes가 링크로 되어있는 경우와 바로 있는 경우가 있음
                    volumes_url = f"{ctrl_url}/Volumes"
                    vol_res = self.session.get(volumes_url, timeout=10)
                    
                    if vol_res.status_code == 200:
                        vol_data = vol_res.json()
                        for vol_member in vol_data.get('Members', []):
                            v_url = f"{self.base_url}{vol_member['@odata.id']}"
                            v_res = self.session.get(v_url, timeout=10)
                            if v_res.status_code == 200:
                                v_data = v_res.json()
                                controller['Volumes'].append({
                                    'Name': v_data.get('Name', ''),
                                    'RaidType': v_data.get('RAIDType', 'Unknown'), # RAID0, RAID1, etc
                                    'CapacityBytes': v_data.get('CapacityBytes', 0),
                                    'BlockSizeBytes': v_data.get('BlockSizeBytes', 0),
                                    'Status': v_data.get('Status', {}).get('Health', 'Unknown')
                                })
                    
                    # 3. Drives (Physical Disks)
                    drives_url = f"{ctrl_url}/Drives"
                    drv_res = self.session.get(drives_url, timeout=10)
                    
                    if drv_res.status_code == 200:
                        drv_data = drv_res.json()
                        for drv_member in drv_data.get('Members', []):
                            d_url = f"{self.base_url}{drv_member['@odata.id']}"
                            d_res = self.session.get(d_url, timeout=10)
                            if d_res.status_code == 200:
                                d_data = d_res.json()
                                controller['Drives'].append({
                                    'Name': d_data.get('Name', ''),
                                    'Model': d_data.get('Model', ''),
                                    'Protocol': d_data.get('Protocol', 'Unknown'), # SATA, SAS, NVMe
                                    'MediaType': d_data.get('MediaType', 'Unknown'), # HDD, SSD
                                    'CapacityBytes': d_data.get('CapacityBytes', 0),
                                    'Status': d_data.get('Status', {}).get('Health', 'Unknown')
                                })
                    
                    controllers.append(controller)
                    
                except Exception as e:
                    print(f"컨트롤러 상세 조회 오류 ({member.get('@odata.id')}): {str(e)}")
            
            return {'Controllers': controllers}
            
        except Exception as e:
            print(f"스토리지 구성 조회 오류: {str(e)}")
            return {'Controllers': []}

    def get_nic_configuration(self):
        """
        NIC 구성 정보 조회 (NetworkAdapters + DeviceFunctions)
        """
        try:
            url = f"{self.base_url}/redfish/v1/Systems/System.Embedded.1/NetworkAdapters"
            response = self.session.get(url, timeout=15)
            
            if response.status_code != 200:
                print(f"NIC 어댑터 목록 조회 실패: {response.status_code}")
                return {'Adapters': []}
            
            data = response.json()
            adapters = []
            
            for member in data.get('Members', []):
                try:
                    # 어댑터 기본 정보
                    adp_url = f"{self.base_url}{member['@odata.id']}"
                    adp_res = self.session.get(adp_url, timeout=10)
                    if adp_res.status_code != 200:
                        continue
                        
                    adp_data = adp_res.json()
                    adapter = {
                        'Id': adp_data.get('Id', ''),
                        'Name': adp_data.get('Name', 'Unknown'),
                        'Manufacturer': adp_data.get('Manufacturer', ''),
                        'Model': adp_data.get('Model', ''),
                        'SerialNumber': adp_data.get('SerialNumber', ''),
                        'FirmwareVersion': '', # LinkStatus 등은 Port에 있음
                        'DeviceFunctions': []
                    }
                    
                    # 펌웨어 버전 추출
                    if 'FirmwarePackageVersion' in adp_data:
                        adapter['FirmwareVersion'] = adp_data['FirmwarePackageVersion']
                    
                    # NetworkDeviceFunctions (iSCSI, PXE 등 설정)
                    funcs_url = f"{adp_url}/NetworkDeviceFunctions"
                    funcs_res = self.session.get(funcs_url, timeout=10)
                    
                    if funcs_res.status_code == 200:
                        funcs_data = funcs_res.json()
                        for f_mem in funcs_data.get('Members', []):
                            f_url = f"{self.base_url}{f_mem['@odata.id']}"
                            f_res = self.session.get(f_url, timeout=10)
                            if f_res.status_code == 200:
                                f_data = f_res.json()
                                # Dell 특화 Attributes 또는 표준 Redfish 속성
                                func_info = {
                                    'Id': f_data.get('Id', ''),
                                    'Name': f_data.get('Name', ''),
                                    'NetBootPMMode': f_data.get('BootMode', 'Unknown'), # Legacy, UEFI
                                    'iSCSIBoot': {}, 
                                    'Ethernet': {} 
                                }
                                
                                # iSCSI Boot 속성 평탄화
                                if 'iSCSIBoot' in f_data:
                                    func_info['iSCSIBoot'] = f_data['iSCSIBoot']
                                    
                                # 이더넷 속성 (MAC 등)
                                if 'Ethernet' in f_data:
                                    func_info['Ethernet'] = {
                                        'MACAddress': f_data['Ethernet'].get('MACAddress', ''),
                                        'MTUSize': f_data['Ethernet'].get('MTUSize', '')
                                    }
                                
                                adapter['DeviceFunctions'].append(func_info)
                                
                    adapters.append(adapter)
                    
                except Exception as e:
                    print(f"NIC 상세 조회 오류: {str(e)}")
            
            return {'Adapters': adapters}
            
        except Exception as e:
            print(f"NIC 구성 조회 오류: {str(e)}")
            return {'Adapters': []}

    def get_boot_settings(self):
        """
        부팅 설정 조회 (Boot Order, Boot Source Override)
        """
        try:
            url = f"{self.base_url}/redfish/v1/Systems/System.Embedded.1"
            response = self.session.get(url, timeout=15)
            
            if response.status_code == 200:
                data = response.json()
                boot = data.get('Boot', {})
                return {
                    'BootOrder': boot.get('BootOrder', []),
                    'BootSourceOverrideTarget': boot.get('BootSourceOverrideTarget', 'None'),
                    'BootSourceOverrideMode': boot.get('BootSourceOverrideMode', 'Legacy'),
                    'BootSourceOverrideEnabled': boot.get('BootSourceOverrideEnabled', 'Disabled')
                }
            return {}
        except Exception as e:
            print(f"부팅 설정 조회 오류: {str(e)}")
            return {}

    def get_firmware_baseline(self):
        """
        Baseline 비교용 펌웨어 목록 (간소화)
        """
        try:
            inventory = self.get_firmware_inventory()
            baseline_fw = {}
            for item in inventory:
                # 키: 컴포넌트 이름 (중복 시 타입/ID 병기하여 유니크하게 만들 필요 있음)
                # 여기서는 단순화를 위해 Name을 Key로 사용하되, 중복되면 덮어씀 (일반적으로 주요 컴포넌트는 유니크함)
                # 또는 {ComponentType}_{Name} 형식 추천
                key = item['Name']
                baseline_fw[key] = item['Version']
            return baseline_fw
        except Exception as e:
            print(f"펌웨어 Baseline 조회 오류: {str(e)}")
            return {}
