# 기본 if문 구조
if 조건:
    # 조건이 참일 때 실행할 코드
    수행할_문장1
    수행할_문장2
else:
    # 조건이 거짓일 때 실행할 코드
    수행할_문장A
    수행할_문장B

# 비교 연산자 사용
x = 10
if x > 0:
    print("양수입니다")

# 논리 연산자 사용
age = 25
money = 5000
if age >= 20 and money >= 10000:
    print("입장 가능")

# in, not in 연산자
fruits = ['apple', 'banana', 'orange']
if 'apple' in fruits:
    print("사과가 있습니다")

# 여러 조건 처리
score = 85
if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
else:
    grade = 'D'

# 중첩 조건문
if score >= 60:
    if score >= 90:
        grade = 'A'
    else:
        grade = 'B'
else:
    grade = 'F'

# 일반적인 if-else문
if score >= 60:
    message = "합격"
else:
    message = "불합격"

# 조건부 표현식
message = "합격" if score >= 60 else "불합격"

# 중첩 조건부 표현식
grade = 'A' if score >= 90 else 'B' if score >= 80 else 'C'

# 아무것도 하지 않을 때
if condition:
    pass
else:
    print("조건이 거짓일 때 실행")

# 함수나 클래스 정의시 임시 코드
def my_function():
    pass

class MyClass:
    pass

# 불리언 값을 정수로 활용
is_valid = True
count = 10 + is_valid  # 11 (True는 1로 계산됨)

# 조건식을 계산식에 활용
value = 100
is_greater_than_50 = value > 50  # True
factor = 2 if is_greater_than_50 else 0.5
result = value * factor  # 200

# 조건식과 리스트 컴프리헨션
numbers = [1, 2, 3, 4, 5]
evens = [n for n in numbers if n % 2 == 0]  # [2, 4]
odds = [n for n in numbers if n % 2 != 0]   # [1, 3, 5]

# 기본 match-case 사용법
status = 404

match status:
    case 200:
        print("OK")
    case 404:
        print("Not Found")
    case 500:
        print("Server Error")
    case _:  # 기본값(default)
        print("Unknown status")

# 패턴 매칭 활용
def process_command(command):
    match command.split():
        case ["quit"]:
            print("종료합니다")
            return True
        case ["help"]:
            print("도움말을 표시합니다")
        case ["add", *items]:
            print(f"추가 항목: {items}")
        case ["delete", item]:
            print(f"삭제 항목: {item}")
        case _:
            print("알 수 없는 명령어입니다")
    return False

# 데이터 구조 매칭
def process_point(point):
    match point:
        case (0, 0):
            print("원점")
        case (0, y):
            print(f"Y축 지점: {y}")
        case (x, 0):
            print(f"X축 지점: {x}")
        case (x, y) if x == y:
            print(f"대각선 지점: {x}")
        case (x, y):
            print(f"일반 지점: ({x}, {y})")

# 클래스 매칭
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

def classify_point(obj):
    match obj:
        case Point(x=0, y=0):
            print("원점")
        case Point(x=0, y=y):
            print(f"Y축 지점: {y}")
        case Point(x=x, y=0):
            print(f"X축 지점: {x}")
        case Point(x=x, y=y) if x == y:
            print(f"대각선 지점: {x}")
        case Point():
            print(f"일반 Point: ({obj.x}, {obj.y})")
        case _:
            print("Point 객체 아님")

# 중첩 if문 사용
def process_data(data):
    if data:
        if isinstance(data, list):
            if len(data) > 0:
                return sum(data)
            else:
                return 0
        else:
            return None
    else:
        return None

# 조기 반환을 사용한 개선
def process_data_improved(data):
    if not data:
        return None
    if not isinstance(data, list):
        return None
    if len(data) == 0:
        return 0
    return sum(data)

# if-elif 체인 사용
def perform_operation(operation, a, b):
    if operation == 'add':
        return a + b
    elif operation == 'subtract':
        return a - b
    elif operation == 'multiply':
        return a * b
    elif operation == 'divide':
        return a / b if b != 0 else None
    else:
        return None

# 디스패치 테이블을 사용한 개선
def add(a, b): return a + b
def subtract(a, b): return a - b
def multiply(a, b): return a * b
def divide(a, b): return a / b if b != 0 else None

operations = {
    'add': add,
    'subtract': subtract,
    'multiply': multiply,
    'divide': divide
}

def perform_operation_improved(operation, a, b):
    if operation not in operations:
        return None
    return operations[operation](a, b)

def calculate_discount(order_total, user_status):
    # 복잡한 중첩 조건문
    if user_status == 'premium':
        if order_total >= 100:
            discount = 0.2
        else:
            discount = 0.1
    elif user_status == 'regular':
        if order_total >= 200:
            discount = 0.15
        else:
            discount = 0.05
    else:
        discount = 0
    
    return order_total * (1 - discount)

# 가드 절을 사용한 개선
def calculate_discount_improved(order_total, user_status):
    # 기본값 설정
    discount = 0
    
    # 프리미엄 회원 처리
    if user_status == 'premium':
        discount = 0.1
        if order_total >= 100:
            discount = 0.2
        return order_total * (1 - discount)
    
    # 일반 회원 처리
    if user_status == 'regular':
        discount = 0.05
        if order_total >= 200:
            discount = 0.15
        return order_total * (1 - discount)
    
    # 비회원 처리
    return order_total

# 효율적인 단락 평가
def is_valid_user(user):
    # user가 None이면 user_id 접근 전에 False 반환
    return user is not None and user.get('id') is not None

# 데이터베이스 조회는 비용이 높은 작업이므로 마지막에 배치
def can_access_resource(user, resource_id):
    if not user:
        return False
    if not resource_id:
        return False
    if not user.is_active:
        return False
    # 비용이 높은 DB 조회는 다른 조건을 만족한 후에 마지막으로 수행
    return database.has_permission(user.id, resource_id)

# 조건 검사 순서가 중요한 상황
def process_event(event):
    # 1. 가장 자주 발생하는 조건을 먼저 검사 (빈도 기반 최적화)
    if event.type == 'COMMON_EVENT':
        return handle_common_event(event)
    
    # 2. 계산 비용이 적은 조건을 먼저 검사 (비용 기반 최적화)
    if not is_valid_format(event):  # 간단한 형식 검사
        return {'error': 'Invalid format'}
    
    # 3. 복잡한 검증 로직은 나중에 실행
    if not is_authorized(event):  # 복잡한 권한 검사
        return {'error': 'Unauthorized'}
    
    # 4. 데이터베이스 조회 같은 비용이 높은 작업은 마지막에
    return process_in_database(event)

# 리스트를 사용한 멤버십 검사 (O(n) 시간 복잡도)
valid_statuses = ['active', 'pending', 'suspended']
if user_status in valid_statuses:
    process_user()

# 세트를 사용한 멤버십 검사 (O(1) 시간 복잡도)
valid_statuses = {'active', 'pending', 'suspended'}
if user_status in valid_statuses:
    process_user()

# 딕셔너리를 사용한 조건 분기 (O(1) 접근)
handlers = {
    'active': handle_active_user,
    'pending': handle_pending_user,
    'suspended': handle_suspended_user
}

if user_status in handlers:
    handlers[user_status](user)

# 설정 값을 읽는 예시 (환경변수 → 설정 파일 → 기본값)
def get_config(key, default=None):
    # 환경 변수에서 먼저 확인
    env_var = os.environ.get(f'APP_{key.upper()}')
    if env_var is not None:
        return env_var
    
    # 설정 파일에서 확인
    if config and key in config:
        return config[key]
    
    # 기본값 사용
    return default

def calculate_investment_return(principal, rate, years):
    # 입력값 유효성 검사
    if not isinstance(principal, (int, float)) or principal <= 0:
        raise ValueError("원금은 양수여야 합니다")
    
    if not isinstance(rate, (int, float)) or rate < 0:
        raise ValueError("이율은 0 이상이어야 합니다")
    
    if not isinstance(years, (int, float)) or years <= 0:
        raise ValueError("기간은 양수여야 합니다")
    
    # 계산 로직
    return principal * ((1 + rate/100) ** years)

class OrderState:
    CREATED = 'created'
    PAID = 'paid'
    SHIPPED = 'shipped'
    DELIVERED = 'delivered'
    CANCELED = 'canceled'

class Order:
    def __init__(self):
        self.state = OrderState.CREATED
    
    def pay(self):
        if self.state == OrderState.CREATED:
            self.state = OrderState.PAID
            return True
        return False
    
    def ship(self):
        if self.state == OrderState.PAID:
            self.state = OrderState.SHIPPED
            return True
        return False
    
    def deliver(self):
        if self.state == OrderState.SHIPPED:
            self.state = OrderState.DELIVERED
            return True
        return False
    
    def cancel(self):
        if self.state in (OrderState.CREATED, OrderState.PAID):
            self.state = OrderState.CANCELED
            return True
        return False

from contextlib import contextmanager

@contextmanager
def conditionally_log(condition, logger):
    """조건부 로깅을 위한 컨텍스트 관리자"""
    if condition:
        logger.info("작업 시작")
        try:
            yield
            logger.info("작업 성공 완료")
        except Exception as e:
            logger.error(f"작업 실패: {e}")
            raise
    else:
        yield  # 로깅 없이 실행

# 사용 예시
import logging
logger = logging.getLogger('app')

debug_mode = True
with conditionally_log(debug_mode, logger):
    # 작업 수행
    result = process_data()