using LiteDB;
using System;

// 데이터 모델 정의
public class GameData
{
    public int Id { get; set; }
    public string PlayerName { get; set; }
    public int Score { get; set; }
    public DateTime CreatedAt { get; set; }
}

// 데이터베이스 초기화
public class DatabaseManager
{
    private string _dbPath;

    public DatabaseManager()
    {
        // Unity 지속성 데이터 경로 사용
        _dbPath = $"{Application.persistentDataPath}/game.db";
        LogSloth.d($"DB_INIT_PATH path:{_dbPath}");
    }

    // 단일 레코드 삽입
    public void InsertData(GameData data)
    {
        using (var db = new LiteDatabase(_dbPath))
        {
            var collection = db.GetCollection<GameData>("gamedata");
            collection.Insert(data);
            LogSloth.d($"DATA_INSERT_SUCCESS id:{data.Id}");
        }
    }

    // 데이터 조회
    public GameData FindById(int id)
    {
        using (var db = new LiteDatabase(_dbPath))
        {
            var collection = db.GetCollection<GameData>("gamedata");
            var result = collection.FindById(id);

            if (result == null)
            {
                LogSloth.e($"NOT_FOUND id:{id}");
            }

            return result;
        }
    }
}

// Flush=true: 즉시 디스크에 쓰기 (느리지만 안전)
var db = new LiteDatabase("Filename=game.db;Flush=true");

// Flush=false: OS 캐시 사용 (빠르지만 전원 차단 시 데이터 손실 가능)
var db = new LiteDatabase("Filename=game.db;Flush=false");

public class BatchInsertManager
{
    private string _dbPath;

    public BatchInsertManager(string dbPath)
    {
        _dbPath = dbPath;
    }

    // 방법 1: InsertBulk 사용 (권장)
    public void InsertBulk(IEnumerable<GameData> dataList)
    {
        using (var db = new LiteDatabase(_dbPath))
        {
            var collection = db.GetCollection<GameData>("gamedata");

            // InsertBulk: 자동으로 배치 분할 및 메모리 관리
            var count = collection.InsertBulk(dataList);
            LogSloth.d($"BULK_INSERT_COMPLETE count:{count}");
        }
    }

    // 방법 2: 수동 트랜잭션 배치
    public void InsertWithTransaction(List<GameData> dataList)
    {
        using (var db = new LiteDatabase(_dbPath))
        {
            // 배치 크기 설정 (메모리 사용량과 성능 균형)
            var batchSize = 1000;
            var totalCount = 0;

            for (var i = 0; i < dataList.Count; i += batchSize)
            {
                // 배치 단위로 트랜잭션 시작
                using (var trans = db.BeginTrans())
                {
                    var collection = db.GetCollection<GameData>("gamedata");
                    var batch = dataList.Skip(i).Take(batchSize);

                    // 배치 내 모든 항목 삽입
                    for (var item of batch)
                    {
                        collection.Insert(item);
                        totalCount++;
                    }

                    // 트랜잭션 커밋 (디스크에 쓰기)
                    trans.Commit();
                    LogSloth.d($"BATCH_COMMIT progress:{i}/{dataList.Count}");
                }
            }

            LogSloth.d($"TRANSACTION_INSERT_COMPLETE total:{totalCount}");
        }
    }

    // 방법 3: 메모리 효율적인 스트림 처리
    public async Task InsertStreamAsync(IAsyncEnumerable<GameData> dataStream)
    {
        using (var db = new LiteDatabase(_dbPath))
        {
            var collection = db.GetCollection<GameData>("gamedata");
            var buffer = new List<GameData>(1000);

            await for (var item of dataStream)
            {
                buffer.Add(item);

                // 버퍼가 가득 차면 flush
                if (buffer.Count >= 1000)
                {
                    collection.InsertBulk(buffer);
                    buffer.Clear();
                    LogSloth.d("BUFFER_FLUSH_COMPLETE");
                }
            }

            // 남은 데이터 처리
            if (buffer.Count > 0)
            {
                collection.InsertBulk(buffer);
                LogSloth.d($"FINAL_FLUSH count:{buffer.Count}");
            }
        }
    }
}

public class CheckpointManager
{
    private LiteDatabase _db;

    public CheckpointManager(string dbPath)
    {
        _db = new LiteDatabase(dbPath);
    }

    // 주기적으로 checkpoint 실행
    public async Task RunPeriodicCheckpoint()
    {
        while (true)
        {
            await Task.Delay(60000); // 1분마다

            // WAL 로그를 메인 데이터베이스 파일로 병합
            _db.Checkpoint();
            LogSloth.d("CHECKPOINT_EXECUTED");
        }
    }

    // 명시적 checkpoint 실행
    public void ForceCheckpoint()
    {
        _db.Checkpoint();
        LogSloth.d("FORCE_CHECKPOINT_COMPLETE");
    }
}

public class TimeBasedSharding
{
    private string _baseDbPath;

    public TimeBasedSharding(string basePath)
    {
        _baseDbPath = basePath;
    }

    // 날짜별 데이터베이스 파일 분할
    public void InsertWithDateSharding(GameData data)
    {
        var dateKey = data.CreatedAt.ToString("yyyyMMdd");
        var dbPath = $"{_baseDbPath}/game_{dateKey}.db";

        using (var db = new LiteDatabase(dbPath))
        {
            var collection = db.GetCollection<GameData>("gamedata");
            collection.Insert(data);
            LogSloth.d($"SHARD_INSERT date:{dateKey} id:{data.Id}");
        }
    }

    // 날짜 범위로 조회
    public List<GameData> QueryByDateRange(DateTime start, DateTime end)
    {
        var results = new List<GameData>();
        var currentDate = start;

        // 날짜 범위 내 모든 샤드 탐색
        while (currentDate <= end)
        {
            var dateKey = currentDate.ToString("yyyyMMdd");
            var dbPath = $"{_baseDbPath}/game_{dateKey}.db";

            if (File.Exists(dbPath))
            {
                using (var db = new LiteDatabase(dbPath))
                {
                    var collection = db.GetCollection<GameData>("gamedata");
                    var shardResults = collection.FindAll().ToList();
                    results.AddRange(shardResults);
                    LogSloth.d($"SHARD_QUERY date:{dateKey} count:{shardResults.Count}");
                }
            }

            currentDate = currentDate.AddDays(1);
        }

        return results;
    }
}

public class IdRangePartitioning
{
    private string _baseDbPath;
    private int _partitionSize = 10000000; // 1000만 행씩 분할

    public IdRangePartitioning(string basePath)
    {
        _baseDbPath = basePath;
    }

    // ID 범위로 파티션 결정
    private string GetPartitionPath(int id)
    {
        var partitionIndex = id / _partitionSize;
        return $"{_baseDbPath}/game_part_{partitionIndex}.db";
    }

    public void InsertWithPartition(GameData data)
    {
        var dbPath = GetPartitionPath(data.Id);

        using (var db = new LiteDatabase(dbPath))
        {
            var collection = db.GetCollection<GameData>("gamedata");
            collection.Insert(data);
        }
    }

    public GameData FindById(int id)
    {
        var dbPath = GetPartitionPath(id);

        if (!File.Exists(dbPath))
        {
            LogSloth.e($"PARTITION_NOT_FOUND id:{id}");
            return null;
        }

        using (var db = new LiteDatabase(dbPath))
        {
            var collection = db.GetCollection<GameData>("gamedata");
            return collection.FindById(id);
        }
    }
}

public class HybridSharding
{
    private string _baseDbPath;

    // 유저 ID 해시 + 날짜 조합
    public string GetShardPath(int userId, DateTime date)
    {
        var userShard = userId % 10; // 10개의 유저 샤드
        var dateKey = date.ToString("yyyyMM"); // 월별 분할
        return $"{_baseDbPath}/game_u{userShard}_{dateKey}.db";
    }

    public void InsertHybridShard(int userId, GameData data)
    {
        var dbPath = GetShardPath(userId, data.CreatedAt);

        using (var db = new LiteDatabase(dbPath))
        {
            var collection = db.GetCollection<GameData>("gamedata");
            collection.Insert(data);
            LogSloth.d($"HYBRID_SHARD_INSERT user:{userId} path:{dbPath}");
        }
    }
}

public class IndexingStrategy
{
    public void CreateOptimalIndexes()
    {
        using (var db = new LiteDatabase("game.db"))
        {
            var collection = db.GetCollection<GameData>("gamedata");

            // 기본 키 인덱스 (자동 생성)
            // collection.EnsureIndex(x => x.Id);

            // 자주 검색하는 필드 인덱스
            collection.EnsureIndex(x => x.PlayerName);
            collection.EnsureIndex(x => x.CreatedAt);

            // 복합 인덱스 (범위 쿼리 최적화)
            collection.EnsureIndex(x => x.Score);

            LogSloth.d("INDEX_CREATION_COMPLETE");
        }
    }

    // 인덱스 활용 쿼리
    public List<GameData> QueryWithIndex(string playerName)
    {
        using (var db = new LiteDatabase("game.db"))
        {
            var collection = db.GetCollection<GameData>("gamedata");

            // 인덱스 사용: O(log n) 복잡도
            var results = collection.Find(x => x.PlayerName == playerName).ToList();
            LogSloth.d($"INDEXED_QUERY count:{results.Count}");

            return results;
        }
    }
}

public class ConnectionOptimization
{
    // 성능 우선 설정
    public LiteDatabase CreatePerformanceDb()
    {
        var connString = "Filename=game.db;" +
                        "Mode=Exclusive;" +        // 단일 프로세스 전용
                        "Flush=false;" +           // OS 캐시 사용
                        "Cache Size=10000;" +      // 캐시 크기 증가
                        "Initial Size=100MB";      // 초기 파일 크기 설정

        return new LiteDatabase(connString);
    }

    // 안전성 우선 설정
    public LiteDatabase CreateSafetyDb()
    {
        var connString = "Filename=game.db;" +
                        "Mode=Shared;" +           // 다중 프로세스 지원
                        "Flush=true;" +            // 즉시 디스크 쓰기
                        "Cache Size=5000";

        return new LiteDatabase(connString);
    }

    // 읽기 전용 설정
    public LiteDatabase CreateReadOnlyDb()
    {
        var connString = "Filename=game.db;" +
                        "Mode=ReadOnly;" +
                        "Cache Size=20000";        // 읽기 캐시 확대

        return new LiteDatabase(connString);
    }
}

public class MemoryOptimization
{
    // 대용량 데이터 스트리밍 조회
    public void StreamLargeResult()
    {
        using (var db = new LiteDatabase("game.db"))
        {
            var collection = db.GetCollection<GameData>("gamedata");

            // FindAll()은 모든 데이터를 메모리에 로드 (위험!)
            // foreach로 스트리밍 처리
            for (var item of collection.FindAll())
            {
                ProcessItem(item);
                // 각 항목 처리 후 메모리 해제
            }
        }
    }

    private void ProcessItem(GameData item)
    {
        // 항목별 처리 로직
        LogSloth.d($"PROCESS_ITEM id:{item.Id}");
    }

    // 페이지네이션 조회
    public List<GameData> GetPage(int pageNumber, int pageSize)
    {
        using (var db = new LiteDatabase("game.db"))
        {
            var collection = db.GetCollection<GameData>("gamedata");

            var results = collection.FindAll()
                .Skip(pageNumber * pageSize)
                .Take(pageSize)
                .ToList();

            LogSloth.d($"PAGE_QUERY page:{pageNumber} size:{pageSize}");
            return results;
        }
    }
}

public class AsyncProcessing
{
    // Unity에서 백그라운드 DB 작업
    public async Task<List<GameData>> LoadDataAsync()
    {
        var results = new List<GameData>();
        var isRunning = true;

        // 백그라운드 스레드에서 DB 작업
        Task.Run(() =>
        {
            using (var db = new LiteDatabase("game.db"))
            {
                var collection = db.GetCollection<GameData>("gamedata");
                results = collection.FindAll().ToList();
                isRunning = false;
            }
        });

        // Unity 메인 스레드에서 대기
        while (isRunning)
        {
            await Task.Delay(100);
        }

        LogSloth.d($"ASYNC_LOAD_COMPLETE count:{results.Count}");
        return results;
    }

    // 배치 작업 비동기 처리
    public async Task BatchInsertAsync(List<GameData> dataList)
    {
        var isRunning = true;
        Exception caughtException = null;

        Task.Run(() =>
        {
            try
            {
                using (var db = new LiteDatabase("game.db"))
                {
                    var collection = db.GetCollection<GameData>("gamedata");
                    collection.InsertBulk(dataList);
                }
            }
            catch (Exception ex)
            {
                caughtException = ex;
            }
            finally
            {
                isRunning = false;
            }
        });

        while (isRunning)
        {
            await Task.Delay(100);
        }

        if (caughtException != null)
        {
            LogSloth.e($"BATCH_INSERT_FAILED error:{caughtException.Message}");
            throw caughtException;
        }

        LogSloth.d($"BATCH_INSERT_SUCCESS count:{dataList.Count}");
    }
}

// SQLite 사용 예제 (Unity)
using SQLite4Unity3d;

public class SQLiteAlternative
{
    private SQLiteConnection _db;

    public void Initialize()
    {
        var dbPath = $"{Application.persistentDataPath}/game.sqlite";
        _db = new SQLiteConnection(dbPath);

        _db.CreateTable<GameData>();
        LogSloth.d("SQLITE_INIT_SUCCESS");
    }

    public void BulkInsert(List<GameData> dataList)
    {
        _db.BeginTransaction();

        for (var item of dataList)
        {
            _db.Insert(item);
        }

        _db.Commit();
        LogSloth.d($"SQLITE_BULK_INSERT count:{dataList.Count}");
    }
}

// PostgreSQL / MySQL 연동
public class CloudDatabaseAlternative
{
    private string _connectionString;

    public async Task<List<GameData>> QueryFromCloud()
    {
        // 클라우드 DB 쿼리 (예: Supabase, Firebase)
        // 100억 행도 처리 가능한 인프라

        LogSloth.d("CLOUD_QUERY_START");
        // ... 클라우드 DB 로직
        return new List<GameData>();
    }
}

public class HybridStrategy
{
    private LiteDatabase _localDb;
    private CloudDatabaseClient _cloudDb;

    // 로컬: 최근 데이터 (1개월)
    // 클라우드: 전체 데이터 (수년)

    public async Task<List<GameData>> QueryWithFallback(DateTime date)
    {
        var isRecent = (DateTime.Now - date).TotalDays < 30;

        if (isRecent)
        {
            // LiteDB에서 빠른 로컬 조회
            using (_localDb)
            {
                var collection = _localDb.GetCollection<GameData>("recent");
                return collection.Find(x => x.CreatedAt >= date).ToList();
            }
        }
        else
        {
            // 클라우드 DB에서 조회
            return await _cloudDb.QueryHistoricalData(date);
        }
    }
}