Chapter 3: CLI 기반 파일 이름 변경 도구¶

import sys
import os
from pathlib import Path
import glob

class BasicCLIRenamer:
    """기본 CLI 파일명 변경 도구"""

    def __init__(self):
        self.files = []  # 발견된 파일들을 저장할 리스트
        print("📁 CLI 파일명 변경 도구 v1.0")
        print("=" * 40)

    def find_files(self, patterns):
        """파일 패턴으로 파일 찾기"""
        self.files = []

        for pattern in patterns:
            # glob을 사용해서 패턴에 맞는 파일들 찾기
            matched_files = glob.glob(pattern)

            for file_path in matched_files:
                # 파일인지 확인하고 절대경로로 변환
                if os.path.isfile(file_path):
                    abs_path = os.path.abspath(file_path)
                    if abs_path not in self.files:  # 중복 방지
                        self.files.append(abs_path)

        return len(self.files)

    def list_files(self):
        """발견된 파일들 목록 출력"""
        if not self.files:
            print("❌ 패턴에 맞는 파일이 없습니다.")
            return

        print(f"📋 발견된 파일: {len(self.files)}개")
        print("-" * 40)

        for i, file_path in enumerate(self.files, 1):
            # 파일명만 표시 (경로는 너무 길어서)
            filename = os.path.basename(file_path)
            file_size = self.get_file_size(file_path)
            print(f"{i:3d}. {filename} ({file_size})")

        print("-" * 40)

    def get_file_size(self, file_path):
        """파일 크기를 읽기 쉬운 형태로 반환"""
        try:
            size = os.path.getsize(file_path)
            if size < 1024:
                return f"{size} B"
            elif size < 1024 * 1024:
                return f"{size/1024:.1f} KB"
            else:
                return f"{size/(1024*1024):.1f} MB"
        except OSError:
            return "알 수 없음"

    def show_help(self):
        """도움말 출력"""
        help_text = """
사용법: python step1_basic_cli.py [파일패턴...]

예시:
  python step1_basic_cli.py *.txt        # 모든 txt 파일
  python step1_basic_cli.py *.py *.js    # py와 js 파일들
  python step1_basic_cli.py "test*.log"  # test로 시작하는 log 파일들
  python step1_basic_cli.py photo_*.jpg  # photo_로 시작하는 jpg 파일들

기능:
  - 파일 패턴 매칭으로 파일 찾기
  - 파일 목록과 크기 정보 표시
  - 중복 파일 자동 제거
"""
        print(help_text)

    def run(self, args):
        """프로그램 실행"""
        # 명령행 인자 확인
        if len(args) < 2:
            print("❌ 파일 패턴을 지정해주세요!")
            self.show_help()
            return 1

        # 도움말 요청 확인
        if args[1] in ["-h", "--help", "help"]:
            self.show_help()
            return 0

        # 파일 패턴들 (첫 번째 인자부터)
        file_patterns = args[1:]

        print(f"🔍 파일 검색 중... 패턴: {', '.join(file_patterns)}")

        # 파일 찾기
        file_count = self.find_files(file_patterns)

        if file_count == 0:
            print("\n💡 팁: 파일이 없을 때 확인사항:")
            print("  - 파일 패턴이 올바른지 확인")
            print("  - 현재 디렉토리에 해당 파일들이 있는지 확인")
            print("  - 따옴표로 패턴을 감싸보세요: \"*.txt\"")
            return 1

        # 파일 목록 출력
        self.list_files()

        print("\n✅ Step 1 완료: 파일 목록을 성공적으로 찾았습니다!")
        print("💡 다음 단계에서는 이 파일들의 이름을 바꿔볼 예정입니다.")

        return 0

def main():
    """메인 함수"""
    renamer = BasicCLIRenamer()
    exit_code = renamer.run(sys.argv)
    sys.exit(exit_code)

# 프로그램 실행
if __name__ == "__main__":
    main()

import sys
import os
import argparse
from pathlib import Path
import glob

class ArgumentParser:
    """명령행 인자 처리기"""

    def __init__(self):
        self.parser = argparse.ArgumentParser(
            prog='renamer',
            description='📁 CLI 기반 파일 이름 변경 도구',
            epilog='예시: python %(prog)s --prefix "new_" *.txt'
        )
        self.setup_arguments()

    def setup_arguments(self):
        """명령행 인자 설정"""

        # 파일 패턴 (위치 인자)
        self.parser.add_argument(
            'files',
            nargs='+',
            help='대상 파일 패턴들 (예: *.txt *.py)'
        )

        # 작업 유형 옵션
        action_group = self.parser.add_mutually_exclusive_group(required=True)
        action_group.add_argument(
            '--prefix', '-p',
            metavar='TEXT',
            help='파일명 앞에 추가할 텍스트'
        )
        action_group.add_argument(
            '--suffix', '-s', 
            metavar='TEXT',
            help='파일명 뒤에 추가할 텍스트'
        )
        action_group.add_argument(
            '--find-replace', '-fr',
            nargs=2,
            metavar=('FIND', 'REPLACE'),
            help='찾을 문자열과 바꿀 문자열'
        )

        # 기타 옵션
        self.parser.add_argument(
            '--dry-run', '-n',
            action='store_true',
            help='실제 변경 없이 미리보기만 표시'
        )
        self.parser.add_argument(
            '--verbose', '-v',
            action='store_true',
            help='상세한 정보 출력'
        )
        self.parser.add_argument(
            '--force', '-f',
            action='store_true',
            help='확인 없이 바로 실행'
        )

    def parse_args(self, args=None):
        """인자 파싱"""
        return self.parser.parse_args(args)

    def print_help(self):
        """도움말 출력"""
        self.parser.print_help()

class CLIRenamer:
    """개선된 CLI 파일명 변경 도구"""

    def __init__(self):
        self.files = []
        self.arg_parser = ArgumentParser()

    def find_files(self, patterns, verbose=False):
        """파일 패턴으로 파일 찾기"""
        self.files = []

        if verbose:
            print("🔍 파일 검색 시작...")

        for pattern in patterns:
            matched_files = glob.glob(pattern)

            if verbose:
                print(f"  패턴 '{pattern}': {len(matched_files)}개 발견")

            for file_path in matched_files:
                if os.path.isfile(file_path):
                    abs_path = os.path.abspath(file_path)
                    if abs_path not in self.files:
                        self.files.append(abs_path)

        if verbose:
            print(f"📋 총 {len(self.files)}개 파일 발견")

        return len(self.files)

    def generate_new_names(self, operation, value1, value2=None):
        """새로운 파일명 생성"""
        new_names = []

        for file_path in self.files:
            directory = os.path.dirname(file_path)
            filename = os.path.basename(file_path)
            name, ext = os.path.splitext(filename)

            if operation == 'prefix':
                new_name = f"{value1}{name}{ext}"
            elif operation == 'suffix':
                new_name = f"{name}{value1}{ext}"
            elif operation == 'find_replace':
                new_name = filename.replace(value1, value2)
            else:
                new_name = filename

            new_path = os.path.join(directory, new_name)
            new_names.append((file_path, new_path))

        return new_names

    def show_preview(self, rename_plan):
        """미리보기 표시"""
        if not rename_plan:
            print("❌ 변경할 파일이 없습니다.")
            return

        print(f"\n👀 미리보기 ({len(rename_plan)}개 파일):")
        print("=" * 60)

        changes = 0
        for old_path, new_path in rename_plan:
            old_name = os.path.basename(old_path)
            new_name = os.path.basename(new_path)

            if old_name != new_name:
                print(f"  {old_name} → {new_name}")
                changes += 1
            else:
                print(f"  {old_name} (변경없음)")

        print("=" * 60)
        print(f"📊 바뀌는 파일: {changes}개 / {len(rename_plan)}개")

    def confirm_execution(self):
        """실행 확인"""
        try:
            response = input("\n실행하시겠습니까? (y/n): ").strip().lower()
            return response in ['y', 'yes', '예']
        except KeyboardInterrupt:
            print("\n❌ 사용자가 취소했습니다.")
            return False

    def execute_rename(self, rename_plan, verbose=False):
        """파일명 변경 실행"""
        if not rename_plan:
            print("❌ 변경할 파일이 없습니다.")
            return 0, []

        success_count = 0
        errors = []

        if verbose:
            print("\n⚙️ 파일명 변경 시작...")

        for old_path, new_path in rename_plan:
            if old_path == new_path:
                if verbose:
                    print(f"  건너뛰기: {os.path.basename(old_path)}")
                continue

            try:
                # 동일한 이름의 파일이 이미 있는지 확인
                if os.path.exists(new_path):
                    errors.append(f"{os.path.basename(old_path)}: 대상 파일이 이미 존재함")
                    continue

                os.rename(old_path, new_path)
                success_count += 1

                if verbose:
                    print(f"  ✅ {os.path.basename(old_path)} → {os.path.basename(new_path)}")

            except Exception as e:
                error_msg = f"{os.path.basename(old_path)}: {str(e)}"
                errors.append(error_msg)

                if verbose:
                    print(f"  ❌ {error_msg}")

        return success_count, errors

    def run(self, args=None):
        """프로그램 실행"""
        try:
            # 인자 파싱
            parsed_args = self.arg_parser.parse_args(args)

            print("📁 CLI 파일명 변경 도구 v2.0")
            print("=" * 40)

            # 파일 찾기
            file_count = self.find_files(parsed_args.files, parsed_args.verbose)

            if file_count == 0:
                print("❌ 패턴에 맞는 파일이 없습니다.")
                return 1

            # 작업 유형 결정
            if parsed_args.prefix:
                operation = 'prefix'
                value1 = parsed_args.prefix
                value2 = None
                print(f"✨ 작업: 접두사 '{value1}' 추가")
            elif parsed_args.suffix:
                operation = 'suffix'
                value1 = parsed_args.suffix
                value2 = None
                print(f"✨ 작업: 접미사 '{value1}' 추가")
            elif parsed_args.find_replace:
                operation = 'find_replace'
                value1, value2 = parsed_args.find_replace
                print(f"✨ 작업: '{value1}' → '{value2}' 바꾸기")

            # 변경 계획 생성
            rename_plan = self.generate_new_names(operation, value1, value2)

            # 미리보기 표시
            self.show_preview(rename_plan)

            # Dry run 모드인 경우 여기서 종료
            if parsed_args.dry_run:
                print("\n🏃 Dry run 모드: 실제 변경은 수행되지 않았습니다.")
                return 0

            # 확인 요청 (포스 모드가 아닌 경우)
            if not parsed_args.force:
                if not self.confirm_execution():
                    print("❌ 사용자가 취소했습니다.")
                    return 0

            # 실제 변경 실행
            success_count, errors = self.execute_rename(rename_plan, parsed_args.verbose)

            # 결과 보고
            print(f"\n📊 결과:")
            print(f"  ✅ 성공: {success_count}개")
            if errors:
                print(f"  ❌ 실패: {len(errors)}개")
                if parsed_args.verbose:
                    for error in errors:
                        print(f"    - {error}")

            if success_count > 0:
                print(f"\n✨ {success_count}개 파일의 이름이 성공적으로 변경되었습니다!")
                return 0
            else:
                print("\n❌ 성공적으로 변경된 파일이 없습니다.")
                return 1

        except KeyboardInterrupt:
            print("\n\n❌ 사용자가 중단했습니다.")
            return 130
        except Exception as e:
            print(f"\n❌ 오류가 발생했습니다: {e}")
            return 1

def main():
    """메인 함수"""
    renamer = CLIRenamer()
    exit_code = renamer.run()
    sys.exit(exit_code)

if __name__ == "__main__":
    main()

import sys
import os
import argparse
import shutil
from pathlib import Path
import glob
from datetime import datetime

class AdvancedCLIRenamer:
    """고급 CLI 파일명 변경 도구"""

    def __init__(self):
        self.files = []
        self.backup_dir = None
        self.setup_argparse()

    def setup_argparse(self):
        """argparse 설정"""
        self.parser = argparse.ArgumentParser(
            prog='renamer-advanced',
            description='🚀 고급 CLI 파일명 변경 도구',
            formatter_class=argparse.RawDescriptionHelpFormatter,
            epilog="""
사용 예시:
  %(prog)s --prefix "new_" *.txt                    # 접두사 추가
  %(prog)s --suffix "_backup" --recursive src/      # 재귀적 접미사 추가
  %(prog)s --prefix "photo_" --backup ./backups/ *.jpg  # 백업과 함께
  %(prog)s --case upper *.py                        # 대소문자 변경
            """
        )

        # 파일 패턴
        self.parser.add_argument(
            'files', nargs='+',
            help='대상 파일 패턴들'
        )

        # 작업 유형
        action_group = self.parser.add_mutually_exclusive_group(required=True)
        action_group.add_argument('--prefix', '-p', help='접두사 추가')
        action_group.add_argument('--suffix', '-s', help='접미사 추가') 
        action_group.add_argument('--case', choices=['upper', 'lower', 'title'], 
                                 help='대소문자 변경')

        # 고급 옵션
        self.parser.add_argument('--recursive', '-r', action='store_true',
                               help='하위 디렉토리까지 재귀적 검색')
        self.parser.add_argument('--backup', metavar='DIR',
                               help='변경 전 백업 디렉토리')
        self.parser.add_argument('--dry-run', '-n', action='store_true',
                               help='미리보기만 표시')
        self.parser.add_argument('--force', '-f', action='store_true',
                               help='확인 없이 실행')
        self.parser.add_argument('--verbose', '-v', action='store_true',
                               help='상세 정보 출력')
        self.parser.add_argument('--extension', '-e', action='append',
                               help='특정 확장자만 처리 (예: -e .txt -e .py)')

    def find_files(self, patterns, recursive=False, extensions=None, verbose=False):
        """파일 찾기 (재귀적 옵션 포함)"""
        self.files = []

        if verbose:
            print(f"🔍 파일 검색 {'(재귀적)' if recursive else '(현재 디렉토리만)'}...")

        for pattern in patterns:
            if recursive:
                # 재귀적 검색을 위해 **/ 패턴 사용
                if not pattern.startswith('**/'):
                    pattern = f"**/{pattern}"
                matched_files = glob.glob(pattern, recursive=True)
            else:
                matched_files = glob.glob(pattern)

            for file_path in matched_files:
                if os.path.isfile(file_path):
                    abs_path = os.path.abspath(file_path)

                    # 확장자 필터 적용
                    if extensions:
                        file_ext = os.path.splitext(abs_path)[1].lower()
                        if file_ext not in extensions:
                            continue

                    if abs_path not in self.files:
                        self.files.append(abs_path)

        if verbose:
            print(f"📋 총 {len(self.files)}개 파일 발견")
            if extensions:
                print(f"🔧 필터링된 확장자: {', '.join(extensions)}")

        return len(self.files)

    def create_backup(self, file_path, backup_dir, verbose=False):
        """파일 백업 생성"""
        if not backup_dir:
            return True

        try:
            # 백업 디렉토리 생성
            os.makedirs(backup_dir, exist_ok=True)

            # 백업 파일명 (타임스탬프 포함)
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = os.path.basename(file_path)
            name, ext = os.path.splitext(filename)
            backup_filename = f"{name}_{timestamp}{ext}"
            backup_path = os.path.join(backup_dir, backup_filename)

            # 파일 복사
            shutil.copy2(file_path, backup_path)

            if verbose:
                print(f"  💾 백업: {backup_filename}")

            return True

        except Exception as e:
            print(f"❌ 백업 실패 {filename}: {e}")
            return False

    def generate_new_names(self, operation, value):
        """새로운 파일명 생성"""
        rename_plan = []

        for file_path in self.files:
            directory = os.path.dirname(file_path)
            filename = os.path.basename(file_path)
            name, ext = os.path.splitext(filename)

            if operation == 'prefix':
                new_name = f"{value}{filename}"
            elif operation == 'suffix':
                new_name = f"{name}{value}{ext}"
            elif operation == 'case':
                if value == 'upper':
                    new_name = filename.upper()
                elif value == 'lower':
                    new_name = filename.lower()
                elif value == 'title':
                    new_name = f"{name.title()}{ext}"
            else:
                new_name = filename

            new_path = os.path.join(directory, new_name)
            rename_plan.append((file_path, new_path))

        return rename_plan

    def show_preview(self, rename_plan, verbose=False):
        """미리보기 표시"""
        if not rename_plan:
            print("❌ 변경할 파일이 없습니다.")
            return

        print(f"\n👀 변경 미리보기 ({len(rename_plan)}개 파일):")
        print("=" * 70)

        changes = 0
        unchanged = 0

        for old_path, new_path in rename_plan:
            old_name = os.path.basename(old_path)
            new_name = os.path.basename(new_path)

            if old_name != new_name:
                if verbose:
                    # 전체 경로 표시
                    print(f"  📂 {old_path}")
                    print(f"  ➡️  {new_path}")
                    print()
                else:
                    print(f"  {old_name} → {new_name}")
                changes += 1
            else:
                if verbose:
                    print(f"  ➖ {old_name} (변경없음)")
                unchanged += 1

        print("=" * 70)
        print(f"📊 변경: {changes}개, 변경없음: {unchanged}개")

        if self.backup_dir:
            print(f"💾 백업 위치: {os.path.abspath(self.backup_dir)}")

    def execute_rename(self, rename_plan, backup_dir=None, verbose=False):
        """파일명 변경 실행"""
        if not rename_plan:
            return 0, []

        success_count = 0
        errors = []

        print("\n⚙️ 파일명 변경 실행 중...")

        for i, (old_path, new_path) in enumerate(rename_plan, 1):
            if old_path == new_path:
                continue

            try:
                # 진행률 표시
                if verbose:
                    print(f"  [{i}/{len(rename_plan)}] {os.path.basename(old_path)}")

                # 백업 생성
                if backup_dir:
                    if not self.create_backup(old_path, backup_dir, verbose):
                        errors.append(f"{os.path.basename(old_path)}: 백업 실패")
                        continue

                # 대상 파일 존재 확인
                if os.path.exists(new_path):
                    errors.append(f"{os.path.basename(old_path)}: 대상 파일이 이미 존재")
                    continue

                # 파일명 변경
                os.rename(old_path, new_path)
                success_count += 1

                if verbose:
                    print(f"    ✅ → {os.path.basename(new_path)}")

            except Exception as e:
                error_msg = f"{os.path.basename(old_path)}: {e}"
                errors.append(error_msg)

                if verbose:
                    print(f"    ❌ {error_msg}")

        return success_count, errors

    def run(self, args=None):
        """프로그램 실행"""
        try:
            parsed_args = self.parser.parse_args(args)

            print("🚀 고급 CLI 파일명 변경 도구 v3.0")
            print("=" * 50)

            # 확장자 처리
            extensions = None
            if parsed_args.extension:
                extensions = [ext if ext.startswith('.') else f'.{ext}' 
                             for ext in parsed_args.extension]

            # 파일 찾기
            file_count = self.find_files(
                parsed_args.files, 
                parsed_args.recursive,
                extensions,
                parsed_args.verbose
            )

            if file_count == 0:
                print("❌ 조건에 맞는 파일이 없습니다.")
                return 1

            # 백업 디렉토리 설정
            self.backup_dir = parsed_args.backup

            # 작업 유형 결정
            if parsed_args.prefix:
                operation, value = 'prefix', parsed_args.prefix
                print(f"✨ 작업: 접두사 '{value}' 추가")
            elif parsed_args.suffix:
                operation, value = 'suffix', parsed_args.suffix
                print(f"✨ 작업: 접미사 '{value}' 추가")
            elif parsed_args.case:
                operation, value = 'case', parsed_args.case
                print(f"✨ 작업: 대소문자를 {value}로 변경")

            # 변경 계획 생성
            rename_plan = self.generate_new_names(operation, value)

            # 미리보기
            self.show_preview(rename_plan, parsed_args.verbose)

            # Dry run 모드
            if parsed_args.dry_run:
                print("\n🏃 Dry run 모드: 실제 변경은 수행되지 않았습니다.")
                return 0

            # 사용자 확인
            if not parsed_args.force:
                try:
                    response = input("\n실행하시겠습니까? (y/n): ").strip().lower()
                    if response not in ['y', 'yes', '예']:
                        print("❌ 사용자가 취소했습니다.")
                        return 0
                except KeyboardInterrupt:
                    print("\n❌ 사용자가 중단했습니다.")
                    return 130

            # 실행
            success_count, errors = self.execute_rename(
                rename_plan, self.backup_dir, parsed_args.verbose
            )

            # 결과 보고
            print(f"\n📊 실행 결과:")
            print(f"  ✅ 성공: {success_count}개")
            if errors:
                print(f"  ❌ 실패: {len(errors)}개")
                if parsed_args.verbose:
                    for error in errors:
                        print(f"    - {error}")

            if success_count > 0:
                print(f"\n🎉 {success_count}개 파일의 이름이 성공적으로 변경되었습니다!")
                if self.backup_dir:
                    print(f"💾 백업이 {self.backup_dir}에 저장되었습니다.")
                return 0
            else:
                return 1

        except KeyboardInterrupt:
            print("\n❌ 사용자가 중단했습니다.")
            return 130
        except Exception as e:
            print(f"❌ 오류: {e}")
            return 1

def main():
    renamer = AdvancedCLIRenamer()
    exit_code = renamer.run()
    sys.exit(exit_code)

if __name__ == "__main__":
    main()

import sys
import os
import argparse
import re
import shutil
from pathlib import Path
import glob
from datetime import datetime

class PowerfulCLIRenamer:
    """강력한 찾기/바꾸기 기능을 가진 CLI 도구"""

    def __init__(self):
        self.files = []
        self.backup_dir = None
        self.setup_argparse()

    def setup_argparse(self):
        """argparse 설정"""
        self.parser = argparse.ArgumentParser(
            prog='renamer-powerful',
            description='💪 강력한 CLI 파일명 변경 도구',
            formatter_class=argparse.RawDescriptionHelpFormatter,
            epilog="""
고급 사용 예시:
  %(prog)s --find "IMG" --replace "Photo" *.jpg           # 단순 찾기/바꾸기
  %(prog)s --regex "(\d+)" --replace "pic_\\1" *.jpg      # 정규식 사용
  %(prog)s --number --start 1 --digits 3 *.mp3           # 연번 매기기
  %(prog)s --remove-spaces *.txt                         # 공백 제거
  %(prog)s --find "old" --replace "new" --ignore-case *.* # 대소문자 무시
            """
        )

        # 파일 패턴
        self.parser.add_argument('files', nargs='+', help='대상 파일 패턴들')

        # 작업 유형 (상호 배타적)
        action_group = self.parser.add_mutually_exclusive_group(required=True)
        action_group.add_argument('--find', help='찾을 문자열')
        action_group.add_argument('--regex', help='찾을 정규표현식 패턴')
        action_group.add_argument('--number', action='store_true', help='연번 매기기')
        action_group.add_argument('--remove-spaces', action='store_true', 
                                help='공백을 언더스코어로 변경')
        action_group.add_argument('--prefix', help='접두사 추가')
        action_group.add_argument('--suffix', help='접미사 추가')

        # 찾기/바꾸기 관련 옵션
        self.parser.add_argument('--replace', help='바꿀 문자열')
        self.parser.add_argument('--ignore-case', '-i', action='store_true',
                               help='대소문자 구분 안함')

        # 연번 매기기 옵션
        self.parser.add_argument('--start', type=int, default=1,
                               help='연번 시작 숫자 (기본값: 1)')
        self.parser.add_argument('--digits', type=int, default=2,
                               help='연번 자릿수 (기본값: 2)')
        self.parser.add_argument('--number-format', default='{number}_{name}',
                               help='연번 형식 (기본값: {number}_{name})')

        # 기타 옵션
        self.parser.add_argument('--recursive', '-r', action='store_true')
        self.parser.add_argument('--backup', metavar='DIR', help='백업 디렉토리')
        self.parser.add_argument('--dry-run', '-n', action='store_true')
        self.parser.add_argument('--force', '-f', action='store_true')
        self.parser.add_argument('--verbose', '-v', action='store_true')
        self.parser.add_argument('--extension', '-e', action='append')

    def find_files(self, patterns, recursive=False, extensions=None, verbose=False):
        """파일 찾기"""
        self.files = []

        for pattern in patterns:
            if recursive:
                pattern = f"**/{pattern}" if not pattern.startswith('**/') else pattern
                matched_files = glob.glob(pattern, recursive=True)
            else:
                matched_files = glob.glob(pattern)

            for file_path in matched_files:
                if os.path.isfile(file_path):
                    abs_path = os.path.abspath(file_path)

                    if extensions:
                        file_ext = os.path.splitext(abs_path)[1].lower()
                        if file_ext not in extensions:
                            continue

                    if abs_path not in self.files:
                        self.files.append(abs_path)

        # 파일명으로 정렬 (연번 매기기를 위해)
        self.files.sort(key=lambda x: os.path.basename(x).lower())

        if verbose:
            print(f"📋 총 {len(self.files)}개 파일 발견 (정렬됨)")

        return len(self.files)

    def generate_new_names(self, args):
        """새로운 파일명 생성"""
        rename_plan = []

        for index, file_path in enumerate(self.files):
            directory = os.path.dirname(file_path)
            filename = os.path.basename(file_path)
            name, ext = os.path.splitext(filename)

            new_name = filename

            if args.find or args.regex:
                # 찾기/바꾸기 또는 정규식
                replace_text = args.replace or ""

                if args.regex:
                    # 정규표현식 모드
                    flags = re.IGNORECASE if args.ignore_case else 0
                    try:
                        new_name = re.sub(args.regex, replace_text, filename, flags=flags)
                    except re.error as e:
                        print(f"❌ 정규식 오류: {e}")
                        new_name = filename

                elif args.find:
                    # 단순 찾기/바꾸기
                    if args.ignore_case:
                        # 대소문자 무시 찾기/바꾸기
                        pattern = re.escape(args.find)
                        new_name = re.sub(pattern, replace_text, filename, flags=re.IGNORECASE)
                    else:
                        new_name = filename.replace(args.find, replace_text)

            elif args.number:
                # 연번 매기기
                number = args.start + index
                number_str = f"{number:0{args.digits}d}"

                # 연번 형식 적용
                format_vars = {
                    'number': number_str,
                    'name': name,
                    'ext': ext[1:] if ext else '',  # 점 제거
                    'original': filename
                }

                try:
                    new_name = args.number_format.format(**format_vars)
                    if not new_name.endswith(ext) and ext:
                        new_name += ext
                except KeyError as e:
                    print(f"❌ 형식 오류: {e}")
                    new_name = f"{number_str}_{filename}"

            elif args.remove_spaces:
                # 공백 제거
                new_name = filename.replace(' ', '_')
                # 연속된 언더스코어 정리
                new_name = re.sub(r'_+', '_', new_name)

            elif args.prefix:
                new_name = f"{args.prefix}{filename}"

            elif args.suffix:
                new_name = f"{name}{args.suffix}{ext}"

            new_path = os.path.join(directory, new_name)
            rename_plan.append((file_path, new_path))

        return rename_plan

    def validate_rename_plan(self, rename_plan):
        """변경 계획 검증"""
        issues = []
        new_names = []

        for old_path, new_path in rename_plan:
            new_name = os.path.basename(new_path)

            # 빈 파일명 체크
            if not new_name or new_name in ['.', '..']:
                issues.append(f"{os.path.basename(old_path)}: 잘못된 파일명")
                continue

            # 중복 파일명 체크
            if new_name in new_names:
                issues.append(f"{new_name}: 중복 파일명")
            else:
                new_names.append(new_name)

            # 파일명 길이 체크 (Windows 기준)
            if len(new_name) > 255:
                issues.append(f"{new_name}: 파일명이 너무 김")

            # 금지된 문자 체크 (Windows)
            forbidden_chars = r'<>:"/\|?*'
            if any(char in new_name for char in forbidden_chars):
                issues.append(f"{new_name}: 금지된 문자 포함")

        return issues

    def show_preview(self, rename_plan, verbose=False):
        """미리보기 표시"""
        if not rename_plan:
            print("❌ 변경할 파일이 없습니다.")
            return

        print(f"\n👀 변경 미리보기 ({len(rename_plan)}개 파일):")
        print("=" * 80)

        changes = 0
        for i, (old_path, new_path) in enumerate(rename_plan):
            old_name = os.path.basename(old_path)
            new_name = os.path.basename(new_path)

            if old_name != new_name:
                if verbose:
                    print(f"  {i+1:3d}. {old_name}")
                    print(f"       ➡️  {new_name}")
                else:
                    print(f"  {i+1:3d}. {old_name} → {new_name}")
                changes += 1
            else:
                if verbose:
                    print(f"  {i+1:3d}. {old_name} (변경없음)")

        print("=" * 80)
        print(f"📊 변경될 파일: {changes}개 / {len(rename_plan)}개")

    def execute_rename(self, rename_plan, backup_dir=None, verbose=False):
        """파일명 변경 실행"""
        if not rename_plan:
            return 0, []

        success_count = 0
        errors = []

        print("\n⚙️ 파일명 변경 실행 중...")

        for i, (old_path, new_path) in enumerate(rename_plan, 1):
            if old_path == new_path:
                continue

            try:
                if verbose:
                    print(f"  [{i}/{len(rename_plan)}] {os.path.basename(old_path)}")

                # 백업 생성
                if backup_dir:
                    os.makedirs(backup_dir, exist_ok=True)
                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                    backup_name = f"{os.path.basename(old_path)}_{timestamp}"
                    backup_path = os.path.join(backup_dir, backup_name)
                    shutil.copy2(old_path, backup_path)

                # 대상 파일 존재 확인
                if os.path.exists(new_path):
                    errors.append(f"{os.path.basename(old_path)}: 대상 파일이 이미 존재")
                    continue

                # 파일명 변경
                os.rename(old_path, new_path)
                success_count += 1

                if verbose:
                    print(f"    ✅ → {os.path.basename(new_path)}")

            except Exception as e:
                error_msg = f"{os.path.basename(old_path)}: {e}"
                errors.append(error_msg)
                if verbose:
                    print(f"    ❌ {error_msg}")

        return success_count, errors

    def run(self, args=None):
        """프로그램 실행"""
        try:
            parsed_args = self.parser.parse_args(args)

            print("💪 강력한 CLI 파일명 변경 도구 v4.0")
            print("=" * 50)

            # 인자 검증
            if (parsed_args.find or parsed_args.regex) and not parsed_args.replace:
                print("❌ --find 또는 --regex 사용 시 --replace가 필요합니다.")
                return 1

            # 확장자 처리
            extensions = None
            if parsed_args.extension:
                extensions = [ext if ext.startswith('.') else f'.{ext}' 
                             for ext in parsed_args.extension]

            # 파일 찾기
            file_count = self.find_files(
                parsed_args.files,
                parsed_args.recursive,
                extensions,
                parsed_args.verbose
            )

            if file_count == 0:
                print("❌ 조건에 맞는 파일이 없습니다.")
                return 1

            # 작업 설명
            if parsed_args.find:
                print(f"✨ 작업: '{parsed_args.find}' → '{parsed_args.replace}' 바꾸기")
                if parsed_args.ignore_case:
                    print("  (대소문자 구분 안함)")
            elif parsed_args.regex:
                print(f"✨ 작업: 정규식 '{parsed_args.regex}' → '{parsed_args.replace}'")
            elif parsed_args.number:
                print(f"✨ 작업: 연번 매기기 (시작: {parsed_args.start}, 자릿수: {parsed_args.digits})")
                print(f"  형식: {parsed_args.number_format}")
            elif parsed_args.remove_spaces:
                print("✨ 작업: 공백을 언더스코어로 변경")
            elif parsed_args.prefix:
                print(f"✨ 작업: 접두사 '{parsed_args.prefix}' 추가")
            elif parsed_args.suffix:
                print(f"✨ 작업: 접미사 '{parsed_args.suffix}' 추가")

            # 변경 계획 생성
            rename_plan = self.generate_new_names(parsed_args)

            # 변경 계획 검증
            issues = self.validate_rename_plan(rename_plan)
            if issues:
                print(f"\n⚠️ 검증 실패 ({len(issues)}개 문제):")
                for issue in issues[:5]:  # 최대 5개만 표시
                    print(f"  - {issue}")
                if len(issues) > 5:
                    print(f"  ... 및 {len(issues)-5}개 추가 문제")
                return 1

            # 미리보기
            self.show_preview(rename_plan, parsed_args.verbose)

            # Dry run 모드
            if parsed_args.dry_run:
                print("\n🏃 Dry run 모드: 실제 변경은 수행되지 않았습니다.")
                return 0

            # 사용자 확인
            if not parsed_args.force:
                try:
                    response = input("\n실행하시겠습니까? (y/n): ").strip().lower()
                    if response not in ['y', 'yes', '예']:
                        print("❌ 사용자가 취소했습니다.")
                        return 0
                except KeyboardInterrupt:
                    print("\n❌ 사용자가 중단했습니다.")
                    return 130

            # 실행
            success_count, errors = self.execute_rename(
                rename_plan, parsed_args.backup, parsed_args.verbose
            )

            # 결과 보고
            print(f"\n📊 실행 결과:")
            print(f"  ✅ 성공: {success_count}개")
            if errors:
                print(f"  ❌ 실패: {len(errors)}개")
                if parsed_args.verbose:
                    for error in errors:
                        print(f"    - {error}")

            if success_count > 0:
                print(f"\n🎉 {success_count}개 파일의 이름이 성공적으로 변경되었습니다!")
                return 0
            else:
                return 1

        except KeyboardInterrupt:
            print("\n❌ 사용자가 중단했습니다.")
            return 130
        except Exception as e:
            print(f"❌ 오류: {e}")
            return 1

def main():
    renamer = PowerfulCLIRenamer()
    exit_code = renamer.run()
    sys.exit(exit_code)

if __name__ == "__main__":
    main()