"""
任务数据模型模块，定义Task相关的数据结构。
# sqlite_practice/models/task.py
"""
from dataclasses import dataclass, field, asdict
from typing import Optional
from datetime import datetime


@dataclass
class Task:
    """任务数据模型类，使用dataclass简化代码"""
    title: str  # 任务标题（必填）
    priority: int = 3  # 优先级（默认3）
    is_completed: bool = False  # 是否完成（默认False）

    task_id: Optional[int] = None  # 任务ID（可选，若不指定，则由数据库自动生成）
    due_date: Optional[str] = None  # 截止日期（可选
    attachment: Optional[str] = None  # 附件（可选）
    created_at: Optional[str] = None  # 创建时间（可选）
    description: Optional[str] = None  # 任务描述（可选）
    last_updated: Optional[str] = None  # 最后更新时间（可选）

    def __post_init__(self):
        """dataclass提供的初始化后自动执行的函数，用于设置默认值"""
        if self.created_at is None:
            #  如果没有提供当前创建时间，则使用当前时间
            self.created_at = datetime.now().strftime('%Y-%m-%d %H:%M:%S')

    def to_dict(self) -> dict:
        """将对象转换为字典，用于数据库操作

        Returns:
            dict: 包含任务数据的字典
        """

        # 使用dataclasses.asdict获取基础字典
        task_dict = asdict(self)

        # SQLite中布尔值以0/1存储，需要转换
        task_dict['is_completed'] = 1 if self.is_completed else 0

        # 如果task_id为None，从字典中移除它
        if self.task_id is None:
            task_dict.pop('task_id')

        return task_dict

    @classmethod
    def from_row(cls, row) -> 'Task':
        """从数据库行创建Task对象
        
        这个方法的作用是将数据库查询结果（SQLite行数据）转换为Task对象。
        看起来复杂是因为它需要处理多种可能的输入格式：
        1. sqlite3.Row对象（有keys方法的字典类对象）
        2. 元组或列表形式的结果
        
        虽然dataclass简化了类定义，但不能自动处理从外部数据源（如数据库）
        创建对象的过程，尤其是当数据需要类型转换时（如整数到布尔值）。
        
        这种复杂性是为了提高代码的健壮性，确保从不同来源的数据都能正确转换为Task对象。
        如果确定数据库始终返回同一格式的结果，可以简化此方法。

        Args:
            row: sqlite3.Row对象或类似字典/序列的对象

        Returns:
            Task: 创建的Task对象
        """
        # 创建一个包含所有可能属性的字典
        task_data = {}

        # 检查row中是否有每个属性并添加到task_data
        # 使用get方法避免KeyError
        if hasattr(row, 'keys'):
            # 如果row有keys方法（如sqlite3.Row），使用它
            for key in row.keys():
                task_data[key] = row[key]
        else:
            # 否则尝试按照索引获取
            try:
                task_data = {
                    'task_id': row[0] if len(row) > 0 else None,
                    'title': row[1] if len(row) > 1 else None,
                    'description': row[2] if len(row) > 2 else None,
                    'priority': row[3] if len(row) > 3 else 3,
                    'due_date': row[4] if len(row) > 4 else None,
                    'is_completed': bool(row[5]) if len(row) > 5 else False,
                    'attachment': row[6] if len(row) > 6 else None,
                    'created_at': row[7] if len(row) > 7 else None,
                    'last_updated': row[8] if len(row) > 8 else None
                }
            except (IndexError, TypeError):
                # 如果索引访问失败，返回具有默认值的Task
                return cls(title="Unknown")

        # 处理布尔值转换
        if 'is_completed' in task_data:
            task_data['is_completed'] = bool(task_data['is_completed'])

        # 创建并返回Task对象
        return cls(**task_data) 

"""
表管理模块，负责SQLite数据库表的创建和基础操作。
提供表结构定义、创建、修改等功能。
"""
import sqlite3
from typing import Dict, Any, List, Optional


class TableManager:
    """表管理类，负责SQLite数据库表的创建和操作"""
    
    def __init__(self, conn: sqlite3.Connection, cursor: sqlite3.Cursor):
        """初始化表管理器
        
        Args:
            conn: 数据库连接对象
            cursor: 数据库游标对象
        """
        self.conn = conn
        self.cursor = cursor
    
    def create_table(self, table_name: str, columns: Dict[str, str]) -> bool:
        """创建数据库表

        Args:
            table_name: 表名
            columns: 表列定义字典，格式为 {列名: 列类型}
            
        Returns:
            bool: 表创建是否成功
        """
        try:
            # 确保连接和游标有效
            if not self.conn or not self.cursor:
                print(f"[Error] 数据库连接或游标无效")
                return False
                
            # 构建列定义字符串
            columns_def = []
            for col_name, col_type in columns.items():
                columns_def.append(f"{col_name} {col_type}")

            create_table_sql = f'''CREATE TABLE IF NOT EXISTS {table_name} (
                {', '.join(columns_def)}
            )'''
            
            self.cursor.execute(create_table_sql)
            self.conn.commit()
            print(f"[Setup] 表 '{table_name}' 已检查/创建。")
            
            return True
            
        except sqlite3.Error as e:
            print(f"[Error] 创建表 '{table_name}' 时出错: {e}")
            return False
            
    def add_column(self, table_name: str, column_name: str, column_type: str) -> bool:
        """向已有表添加新列
        
        Args:
            table_name: 表名
            column_name: 列名
            column_type: 列类型和约束
            
        Returns:
            bool: 添加列是否成功
        """
        try:
            alter_sql = f"ALTER TABLE {table_name} ADD COLUMN {column_name} {column_type}"
            self.cursor.execute(alter_sql)
            self.conn.commit()
            print(f"[Setup] 已向表 '{table_name}' 添加列 '{column_name} {column_type}'")
            return True
        except sqlite3.Error as e:
            print(f"[Error] 向表 '{table_name}' 添加列时出错: {e}")
            return False
            
    def table_exists(self, table_name: str) -> bool:
        """检查表是否存在
        
        Args:
            table_name: 表名
            
        Returns:
            bool: 表是否存在
        """
        try:
            self.cursor.execute(f"SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
            return self.cursor.fetchone() is not None
        except sqlite3.Error as e:
            print(f"[Error] 检查表 '{table_name}' 是否存在时出错: {e}")
            return False
            
    def get_table_info(self, table_name: str) -> List[Dict[str, Any]]:
        """获取表结构信息
        
        Args:
            table_name: 表名
            
        Returns:
            list: 包含列信息的字典列表
        """
        try:
            self.cursor.execute(f"PRAGMA table_info({table_name})")
            columns = []
            for row in self.cursor.fetchall():
                column_info = {
                    'cid': row['cid'],
                    'name': row['name'],
                    'type': row['type'],
                    'notnull': row['notnull'],
                    'default_value': row['dflt_value'],
                    'pk': row['pk']
                }
                columns.append(column_info)
            return columns
        except sqlite3.Error as e:
            print(f"[Error] 获取表 '{table_name}' 信息时出错: {e}")
            return [] 

# 传统方式定义类
class CoinTransTraditional:
    def __init__(
        self,
        id: str,
        symbol: str,
        price: float,
        is_success: bool,
        addrs: list,
    ) -> None:
        self.id = id
        self.symbol = symbol
        self.price = price
        self.is_success = is_success 
        self.addrs = addrs
        
    # 为了方便打印，需要自己实现 __str__ 或 __repr__
    def __repr__(self) -> str:
        # repr 通常返回更详细、无歧义的表示
        return (f"CoinTransTraditional(id='{self.id}', symbol='{self.symbol}', "
                f"price={self.price}, is_success={self.is_success}, addrs={self.addrs})")

# 使用传统类
if __name__ == "__main__":
    coin_trans_trad = CoinTransTraditional("id01", "BTC/USDT", 71000.0, True, ["0x1111", "0x2222"])
    # 需要实现 __repr__ 或 __str__ 才能得到有意义的打印输出
    print(coin_trans_trad) 

from dataclasses import dataclass, field # 导入 dataclass 和 field
from typing import List # 使用 List 进行类型提示

# 使用 @dataclass 装饰器
@dataclass
class CoinTransDataclass:
    # 只需声明属性及其类型提示
    id: str
    symbol: str
    price: float
    is_success: bool
    addrs: List[str] # 使用 List[str] 提供更精确的类型提示

# 使用 dataclass
if __name__ == "__main__":
    coin_trans_dc = CoinTransDataclass("id01", "BTC/USDT", 71000.0, True, ["0x1111", "0x2222"])
    # dataclass 自动生成了 __init__ 和 __repr__ 方法！
    print(coin_trans_dc) 

from dataclasses import dataclass, field
from typing import List

# 工厂函数，用于生成默认的列表
def default_addr_list() -> List[str]:
    print("  (调用了 default_addr_list 工厂函数)") # 演示工厂函数何时被调用
    return ["0xdefault1", "0xdefault2"]

@dataclass
class CoinTransWithDefaults:
    id: str = "default_id"       # 字符串默认值
    symbol: str = "BTC/USDT"     # 字符串默认值
    price: float = 0.0           # 数值默认值
    is_success: bool = False     # 布尔默认值
    
    # 对于 list (可变类型)，使用 default_factory 指定生成函数
    addrs: List[str] = field(default_factory=default_addr_list) 
    
    # 另一个例子: 默认空列表
    # related_ids: List[str] = field(default_factory=list)

# 使用带默认值的 dataclass
if __name__ == "__main__":
    print("\n--- Dataclass 默认值示例 ---")
    # 不提供参数，将使用默认值
    default_trans = CoinTransWithDefaults() 
    print("创建第一个实例:")
    print(default_trans)
    
    # 再创建一个实例，验证列表是独立的
    print("创建第二个实例:")
    another_default = CoinTransWithDefaults()
    print(another_default)
    
    # 修改第一个实例的列表，不应影响第二个
    default_trans.addrs.append("0xadded")
    print("修改第一个实例的 addrs 后:")
    print(f"  实例1: {default_trans}")
    print(f"  实例2: {another_default}") # 实例2的列表未受影响

@dataclass
class SensitiveData:
    username: str
    session_id: str
    # 不希望 token 出现在 repr 输出中
    token: str = field(repr=False) 
    # 也可以给 token 设置默认值或 default_factory
    # token: str = field(default="dummy_token", repr=False) 

if __name__ == "__main__":
     print("\n--- Dataclass 隐藏字段示例 ---")
     data = SensitiveData("user1", "sess123", token="secret_token_value")
     print(data) # 输出中不会包含 token
     # 但仍然可以访问该属性
     print(f"  访问隐藏的 token: {data.token}") 

@dataclass(frozen=True) # 设置为只读
class ImmutablePoint:
    x: float
    y: float

if __name__ == "__main__":
     print("\n--- Dataclass 只读对象示例 ---")
     p = ImmutablePoint(1.0, 2.0)
     print(p)
     # 尝试修改属性会抛出 FrozenInstanceError
     try:
         p.x = 5.0 
     except Exception as e:
         print(f"  尝试修改只读对象失败: {type(e).__name__}: {e}")

from dataclasses import astuple, asdict, dataclass


@dataclass
class SimpleConfig:
    host: str = "localhost"
    port: int = 8080
    debug_mode: bool = False


if __name__ == "__main__":
    print("\n--- Dataclass 转换示例 ---")
    config = SimpleConfig(port=9000)

    # 转换为元组
    config_tuple = astuple(config)
    print(f"  转换为元组: {config_tuple}")

    # 转换为字典
    config_dict = asdict(config)
    print(f"  转换为字典: {config_dict}")

"""
任务数据模型模块，定义Task相关的数据结构。
# sqlite_practice/models/task.py
"""
from dataclasses import dataclass, field
from typing import Optional
from datetime import datetime


@dataclass
class Task:
    """任务数据模型类，使用dataclass简化代码"""
    
    title: str  # 任务标题，必填
    description: Optional[str] = None  # 任务描述，可选
    priority: int = 3  # 优先级，默认为3
    due_date: Optional[str] = None  # 截止日期，可选
    is_completed: bool = False  # 是否完成，默认为False
    attachment: Optional[bytes] = None  # 附件，可选
    created_at: Optional[str] = None  # 创建时间，可选
    last_updated: Optional[str] = None  # 最后更新时间，可选
    task_id: Optional[int] = None  # 任务ID，由数据库生成
    
    def __post_init__(self):
        """对象初始化后运行的方法，用于设置默认值"""
        if self.created_at is None:
            # 如果没有提供创建时间，设置为当前时间
            self.created_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    
    def to_dict(self) -> dict:
        """将对象转换为字典，用于数据库操作
        
        Returns:
            dict: 包含任务数据的字典
        """
        task_dict = {
            'title': self.title,
            'description': self.description,
            'priority': self.priority,
            'due_date': self.due_date,
            'is_completed': 1 if self.is_completed else 0,  # SQLite中布尔值以0/1存储
            'attachment': self.attachment,
            'created_at': self.created_at,
            'last_updated': self.last_updated
        }
        
        # 只有在task_id存在时才添加到字典中
        if self.task_id is not None:
            task_dict['task_id'] = self.task_id
            
        return task_dict
    
    @classmethod
    def from_row(cls, row) -> 'Task':
        """从数据库行创建Task对象
        
        Args:
            row: sqlite3.Row对象或类似字典的对象
            
        Returns:
            Task: 创建的Task对象
        """
        # 创建一个包含所有可能属性的字典
        task_data = {}
        
        # 检查row中是否有每个属性并添加到task_data
        # 使用get方法避免KeyError
        if hasattr(row, 'keys'):
            # 如果row有keys方法（如sqlite3.Row），使用它
            for key in row.keys():
                task_data[key] = row[key]
        else:
            # 否则尝试按照索引获取
            try:
                task_data = {
                    'task_id': row[0] if len(row) > 0 else None,
                    'title': row[1] if len(row) > 1 else None,
                    'description': row[2] if len(row) > 2 else None,
                    'priority': row[3] if len(row) > 3 else 3,
                    'due_date': row[4] if len(row) > 4 else None,
                    'is_completed': bool(row[5]) if len(row) > 5 else False,
                    'attachment': row[6] if len(row) > 6 else None,
                    'created_at': row[7] if len(row) > 7 else None,
                    'last_updated': row[8] if len(row) > 8 else None
                }
            except (IndexError, TypeError):
                # 如果索引访问失败，返回具有默认值的Task
                return cls(title="Unknown")
        
        # 处理布尔值转换
        if 'is_completed' in task_data:
            task_data['is_completed'] = bool(task_data['is_completed'])
            
        # 创建并返回Task对象
        return cls(**task_data) 

"""
任务数据访问层模块，实现对Task数据的CRUD操作。
"""
import sqlite3
from typing import List, Optional, Dict, Any, Tuple
from models.task import Task
from core.table_manager import TableManager


class TaskRepository:
    """任务数据访问类，实现对Task表的增删改查操作"""

    def __init__(self, conn: sqlite3.Connection, cursor: sqlite3.Cursor):
        self.conn = conn
        self.cursor = cursor
        self.table_name = 'tasks'  # 表名
        self.table_manager = TableManager(self.conn, self.cursor)

    def create_table(self) -> bool:
        """创建任务表"""
        columns = {
            "task_id": "INTEGER PRIMARY KEY AUTOINCREMENT",  # 任务ID
            "title": "TEXT NOT NULL",  # 任务标题
            "description": "TEXT",  # 任务描述
            "priority": "INTEGER DEFAULT 3",  # 优先级，默认3
            "due_date": "DATE",  # 截止日期
            "is_completed": "BOOLEAN DEFAULT 0",  # 是否完成，默认False
            "attachment": "BLOB",  # 附件，用于存储文件
            "created_at": "TIMESTAMP DEFAULT CURRENT_TIMESTAMP",  # 创建时间
            "last_updated": "TIMESTAMP"  # 最后更新时间
        }
        # 调用TableManager的create_table方法创建任务表
        created_flag = self.table_manager.create_table(self.table_name, columns)
        return created_flag

    def add_column(self, column_name: str, column_type: str) -> bool:
        """向任务表添加新列
        Args:
            column_name: 新列名
            column_type: 新列类型
            
        """
        added_flag = self.table_manager.add_column(self.table_name, column_name, column_type)
        return added_flag

    def get_table_info(self) -> List[Dict[str, Any]]:
        """获取任务表结构信息
        Returns:
            list: 包含列信息的字典列表
        """
        table_info = self.table_manager.get_table_info(self.table_name)
        return table_info

    def insert_task(self, task: Task) -> Optional[int]:
        """插入新任务
        Args:
            task: Task对象
        Returns:
            int: 新任务的ID，如果插入失败返回None
        """
        try:
            # 将Task对象转换为字典
            task_dict = task.to_dict()

            # 如果存在task_id，则从字典中移除，因为它是自增的
            if 'task_id' in task_dict:
                del task_dict['task_id']

            # 构建INSERT语句
            columns = ', '.join(task_dict.keys())
            """
            placeholders的执行逻辑：类似于下方的代码
            task_dict = {'task1': 'value1', 'task2': 'value2', 'task3': 'value3'}
            question_marks = ', '.join(['?' for _ in task_dict])
            print(question_marks)  # 输出: ?, ?, ?
            '"""
            placeholders = placeholders = ', '.join(['?' for _ in task_dict])
            values = tuple(task_dict.values())
            insert_sql = f"INSERT INTO {self.table_name} ({columns}) VALUES ({placeholders})"
            # 执行插入操作
            self.cursor.execute(insert_sql, values)
            self.conn.commit()
            # 获取新插入记录的ID
            inserted_id = self.cursor.lastrowid
            print(f"[Info] 成功插入任务: '{task.title}', ID: {inserted_id}")
            return inserted_id
        except sqlite3.Error as e:
            print(f"[Error] 任务插入失败: {e}")
            self.conn.rollback()
            return None

    def insert_many(self, tasks: List[Task]) -> Optional[int]:
        """批量插入任务记录

        Args:
            tasks: 要插入的Task对象列表

        Returns:
            int: 成功插入的记录数，如果插入失败则返回None
        """
        try:
            # 确保有任务要插入
            if not tasks:
                print("[Warning] 没有任务要插入")
                return 0
            # 将所有Task对象转换为字典
            task_dicts = [task.to_dict() for task in tasks]
            # 移除所有task_id，因为它们是自增的
            for task_dict in task_dicts:
                if 'task_id' in task_dict:
                    del task_dict['task_id']
            # 确保所有任务的字段相同
            columns = list(task_dicts[0].keys())
            placeholders = ', '.join(['?' for _ in columns])

            # 构建INSERT语句
            insert_sql = f"INSERT INTO {self.table_name} ({', '.join(columns)}) VALUES ({placeholders})"

            # 准备批量插入的值
            # 这段代码使用列表推导式创建一个包含所有任务数据的列表:
            # 1. 外层循环遍历每个任务字典(task_dicts中的每个task_dict)
            # 2. 内层循环按照columns中定义的列顺序提取每个任务字典中的值
            # 3. 使用tuple()将每个任务的值转换为元组，确保与executemany()方法兼容
            # 4. 最终生成的values是一个元组列表，每个元组包含一个任务的所有字段值
            # 例如: [(任务1的值1, 任务1的值2...), (任务2的值1, 任务2的值2...), ...]
            values = [tuple(task_dict[col] for col in columns) for task_dict in task_dicts]
            print(f"[Info] 准备批量插入{len(values)}条任务")

            # 执行批量插入
            self.cursor.executemany(insert_sql, values)
            self.conn.commit()

            # 获取新插入记录的数量
            inserted_count = self.cursor.rowcount
            print(f"[Info] 成功插入{inserted_count}条任务")
            return inserted_count
        except sqlite3.Error as e:
            print(f"[Error] 任务插入失败: {e}")
            self.conn.rollback()
            return None

    def update_task(self, task: Task) -> bool:
        """更新任务记录
        Args:
            task: 要更新的Task对象，必须包含task_id
        Returns:
            bool: 是否更新成功
        """
        try:
            # 检查task_id是否存在
            if task.task_id is None:
                print("[Error] 无法更新任务：缺少task_id")
                return False
            # 将Task对象转换为字典
            task_dict = task.to_dict()

            # 从字典中移除task_id，他讲在WHERE子句中使用
            task_id = task_dict.pop('task_id')

            # 构建SET字句
            """
            这将生成类似于下面的SQL语句：
            UPDATE tasks SET title = 'task1', description = 'task1 description', priority = 1, due_date = '2022-01-01', is_completed = 1, attachment = b'123456', last_updated = '2022-01-01 00:00:00' WHERE task_id = 1
            """
            set_clause = ', '.join([f"{col} = ?" for col in task_dict.keys()])

            # 检查task_dict中是否已包含last_updated字段
            if 'last_updated' not in task_dict:
                # 如果没有包含last_updated字段，则使用SQLite的CURRENT_TIMESTAMP函数
                # 这样可以确保last_updated字段使用数据库服务器的当前时间
                set_clause += ", last_updated = CURRENT_TIMESTAMP"

            # 构建UPDATE语句
            update_sql = f"UPDATE {self.table_name} SET {set_clause} WHERE task_id = ?"
            # 准备参数值
            values = list(task_dict.values())
            values.append(task_id)
            
            # 执行更新操作
            self.cursor.execute(update_sql, values)
            self.conn.commit()

            # 检查是否有行被更新
            updated_count = self.cursor.rowcount
            if updated_count > 0:
                print(f"[Info] 成功更新任务 ID={task_id}")
                return True
            else:
                print(f"[Warning] 未找到要更新的任务 ID={task_id}")
                return False
        except sqlite3.Error as e:
            print(f"[Error] 任务更新失败: {e}")
            self.conn.rollback()
            return False

    def delete_task(self, task_id: int) -> bool:
        """删除任务记录
        Args:
            task_id: 要删除的任务ID
        Returns:
            bool: 是否删除成功
        """
        try:
            #   构建DELETE语句
            delete_sql = f"DELETE FROM {self.table_name} WHERE task_id = ?"

            # 执行删除操作
            self.cursor.execute(delete_sql, (task_id,))

            # 检查是否有行被删除
            deleted_count = self.cursor.rowcount
            if deleted_count > 0:
                print(f"[Info] 成功删除任务 ID={task_id}")
                return True
            else:
                print(f"[Warning] 未找到要删除的任务 ID={task_id}")
                return False
        except sqlite3.Error as e:
            print(f"[Error] 任务删除失败: {e}")
            self.conn.rollback()
            return False

    def find_task_by_id(self, task_id: int) -> Optional[Task]:
        """根据任务ID查找任务记录"""
        try:
            # 构建SELECT语句
            select_sql = f"SELECT * FROM {self.table_name} WHERE task_id = ?"

            # 执行查询操作
            self.cursor.execute(select_sql, (task_id,))

            #  获取查询结果
            row = self.cursor.fetchone()

            # 如果未找到，返回None
            if row is None:
                return None

            # 将结果转换为Task对象
            return Task.from_row(row)
        except sqlite3.Error as e:
            print(f"[Error] 任务查找失败: {e}")
            return None

    def find_all_tasks(self) -> List[Task]:
        """查找所有任务记录"""
        try:
            # 构建SELECT语句
            select_sql = f"SELECT * FROM {self.table_name}"

            # 执行查询操作
            self.cursor.execute(select_sql)

            # 获取所有结果
            rows = self.cursor.fetchall()

            # 将结果转换为Task对象列表
            return [Task.from_row(row) for row in rows]
        except sqlite3.Error as e:
            print(f"[Error] 任务查找失败: {e}")
            return []

    def find_by_criteria(self, criteria: Dict[str, Any]) -> List[Task]:
        """根据条件查找任务

        Args:
            criteria: 查询条件字典，格式为 {列名: 值}

        Returns:
            list: 符合条件的Task对象列表
        """
        try:
            # 确保有条件要查询
            if not criteria:
                return self.find_all_tasks()
            # 构建WHERE子句
            values = []  # 用于占位符
            where_clauses = []  # 用于条件
            for col, val in criteria.items():
                where_clauses.append(f"{col} = ?")
                values.append(val)
            where_clause = ' AND '.join(where_clauses)  # 例如：查询条件: priority = ? 若有多个条件，则用AND连接

            # 构建SELECT语句
            select_sql = f"SELECT * FROM {self.table_name} WHERE {where_clause}"

            # 执行查询操作
            self.cursor.execute(select_sql, values)

            # 获取所有结果
            rows = self.cursor.fetchall()

            # 奖结果转换为Task对象列表
            return [Task.from_row(row) for row in rows]


        except sqlite3.Error as e:
            print(f"[Error] 任务查找失败: {e}")
            return []

    def find_by_title_contains(self, title_part: str) -> List[Task]:
        """根据标题部分查找任务"""
        try:
            # 构建SELECT语句 使用LIKE模糊查询
            select_sql = f"SELECT * FROM {self.table_name} WHERE title LIKE ?"
            # 执行查询，使用%作为通配符
            self.cursor.execute(select_sql, (f'%{title_part}%',))
            # 获取所有结果
            rows = self.cursor.fetchall()

            # 将结果转换为Task对象列表
            return [Task.from_row(row) for row in rows]
        except sqlite3.Error as e:
            print(f"[Error] 任务查找失败: {e}")
            return []

"""
任务服务模块，提供业务逻辑层功能。
负责处理任务相关的业务规则和操作。
# sqlite_practice/services/task_service.py
"""
from typing import List, Optional, Dict, Any
from datetime import datetime, timedelta
from models.task import Task
from repositories.task_repository import TaskRepository


class TaskService:
    """任务服务类，处理任务相关的业务逻辑"""
    
    def __init__(self, task_repository: TaskRepository):
        """初始化任务服务
        
        Args:
            task_repository: 任务数据访问对象
        """
        self.task_repository = task_repository
    
    def create_task(self, title: str, description: str = None, priority: int = 3, 
                   due_date: str = None, is_completed: bool = False, 
                   attachment: bytes = None) -> Optional[int]:
        """创建新任务
        
        Args:
            title: 任务标题
            description: 任务描述
            priority: 优先级 (1-5)，默认为3
            due_date: 截止日期，格式为'YYYY-MM-DD'
            is_completed: 是否已完成
            attachment: 附件数据
            
        Returns:
            int: 新创建任务的ID，失败则返回None
        """
        # 验证优先级范围
        if priority < 1 or priority > 5:
            print(f"[Warning] 优先级 {priority} 超出范围 (1-5)，将使用默认值 3")
            priority = 3
            
        # 验证日期格式
        if due_date:
            try:
                # 尝试解析日期格式
                datetime.strptime(due_date, '%Y-%m-%d')
            except ValueError:
                print(f"[Warning] 日期格式 '{due_date}' 无效，应为 'YYYY-MM-DD'，将设为空")
                due_date = None
                
        # 验证标题不为空
        if not title:
            print("[Error] 任务标题不能为空")
            return None
            
        # 创建任务对象
        task = Task(
            title=title,
            description=description,
            priority=priority,
            due_date=due_date,
            is_completed=is_completed,
            attachment=attachment
        )
        
        # 保存任务
        return self.task_repository.insert_task(task)
    
    def create_tasks_batch(self, task_data_list: List[Dict[str, Any]]) -> Optional[int]:
        """批量创建任务
        
        Args:
            task_data_list: 包含任务数据的字典列表
            
        Returns:
            int: 成功创建的任务数量，失败则返回None
        """
        if not task_data_list:
            print("[Warning] 没有任务数据需要创建")
            return 0
            
        tasks = []
        for task_data in task_data_list:
            # 验证必要字段
            if 'title' not in task_data or not task_data['title']:
                print("[Warning] 跳过缺少标题的任务")
                continue
                
            # 创建任务对象
            task = Task(
                title=task_data['title'],
                description=task_data.get('description'),
                priority=task_data.get('priority', 3),
                due_date=task_data.get('due_date'),
                is_completed=task_data.get('is_completed', False),
                attachment=task_data.get('attachment')
            )
            tasks.append(task)
            
        if not tasks:
            print("[Warning] 没有有效的任务需要创建")
            return 0
            
        # 批量保存任务
        return self.task_repository.insert_many(tasks)
    
    def update_task(self, task_id: int, **kwargs) -> bool:
        """更新任务
        
        Args:
            task_id: 要更新的任务ID
            **kwargs: 要更新的字段和值
            
        Returns:
            bool: 更新是否成功
        """
        # 查找现有任务
        task = self.task_repository.find_task_by_id(task_id)
        if not task:
            print(f"[Error] 未找到要更新的任务 ID={task_id}")
            return False
            
        # 更新字段
        for key, value in kwargs.items():
            if hasattr(task, key):
                setattr(task, key, value)
            else:
                print(f"[Warning] 忽略未知字段 '{key}'")
                
        # 保存更新
        return self.task_repository.update_task(task)
    
    def complete_task(self, task_id: int) -> bool:
        """将任务标记为已完成
        
        Args:
            task_id: 要标记的任务ID
            
        Returns:
            bool: 操作是否成功
        """
        return self.update_task(task_id, is_completed=True)
    
    def delete_task(self, task_id: int) -> bool:
        """删除任务
        
        Args:
            task_id: 要删除的任务ID
            
        Returns:
            bool: 删除是否成功
        """
        return self.task_repository.delete_task(task_id)
    
    def get_task(self, task_id: int) -> Optional[Task]:
        """获取指定ID的任务
        
        Args:
            task_id: 任务ID
            
        Returns:
            Task: 任务对象，未找到则返回None
        """
        return self.task_repository.find_task_by_id(task_id)
    
    def get_all_tasks(self) -> List[Task]:
        """获取所有任务
        
        Returns:
            list: 任务对象列表
        """
        return self.task_repository.find_all_tasks()
    
    def get_tasks_by_priority(self, priority: int) -> List[Task]:
        """获取指定优先级的任务
        
        Args:
            priority: 优先级
            
        Returns:
            list: 任务对象列表
        """
        return self.task_repository.find_by_criteria({'priority': priority})
    
    def get_incomplete_tasks(self) -> List[Task]:
        """获取未完成的任务
        
        Returns:
            list: 任务对象列表
        """
        return self.task_repository.find_by_criteria({'is_completed': 0})  # SQLite中布尔值存储为0/1
    
    def get_overdue_tasks(self) -> List[Task]:
        """获取已逾期的任务
        
        Returns:
            list: 任务对象列表
        """
        today = datetime.now().strftime('%Y-%m-%d')
        
        # 获取所有任务
        all_tasks = self.task_repository.find_all_tasks()
        
        # 筛选出截止日期已过且未完成的任务
        overdue_tasks = []
        for task in all_tasks:
            if (task.due_date and task.due_date < today and not task.is_completed):
                overdue_tasks.append(task)
                
        return overdue_tasks
    
    def search_tasks_by_title(self, title_part: str) -> List[Task]:
        """搜索标题包含指定字符串的任务
        
        Args:
            title_part: 标题中要搜索的文本
            
        Returns:
            list: 符合条件的任务对象列表
        """
        return self.task_repository.find_by_title_contains(title_part)
    
    def get_tasks_due_within_days(self, days: int) -> List[Task]:
        """获取指定天数内到期的任务
        
        Args:
            days: 天数
            
        Returns:
            list: 任务对象列表
        """
        today = datetime.now()
        end_date = (today + timedelta(days=days)).strftime('%Y-%m-%d')
        today_str = today.strftime('%Y-%m-%d')
        
        # 获取所有任务
        all_tasks = self.task_repository.find_all_tasks()
        
        # 筛选出在指定日期范围内到期的任务
        due_tasks = []
        for task in all_tasks:
            if (task.due_date and today_str <= task.due_date <= end_date):
                due_tasks.append(task)
                
        return due_tasks

"""
基本数据库操作示例模块，展示SQLite数据库的基本CRUD操作。
包括连接、创建表、增删改查等基本功能。
"""
import os
import sqlite3
from typing import List, Optional
from core.db_manager import DatabaseManager
from core.table_manager import TableManager
from models.task import Task
from repositories.task_repository import TaskRepository

class SQLiteExample:
    """SQLite基本操作示例类，实现单例模式"""
    
    _instance = None
    
    def __new__(cls, *args, **kwargs):
        """确保类只有一个实例"""
        if cls._instance is None:
            cls._instance = super(SQLiteExample, cls).__new__(cls)
            cls._instance._initialized = False
        return cls._instance
    
    def __init__(self, db_file: str = "sqlite_practice.db"):
        """初始化SQLite示例类"""
        # 避免重复初始化
        if self._initialized:
            return
            
        self.db_file = db_file
        self.db_manager = DatabaseManager(self.db_file)
        self.conn, self.cursor = self.db_manager.connect()
        self.task_repository = TaskRepository(self.conn, self.cursor)
        self.init_db()
        self._initialized = True
    def init_db(self) -> bool:
        """初始化数据库和表结构
        
        Returns:
            bool: 初始化是否成功
        """
        try:
            # 若数据库文件存在，则删除原有数据库
            if os.path.exists(self.db_file):
                self.clean_db()
            # 创建任务表
            return self.task_repository.create_table()
        except Exception as e:
            print(f"[Error] 初始化数据库失败: {e}")
            return False
    
    def clean_db(self) -> bool:
        """清理数据库文件
        
        Returns:
            bool: 清理是否成功
        """
        return self.db_manager.clean_database()
    
    def insert_sample_tasks(self) -> int:
        """插入示例任务数据
        
        Returns:
            int: 成功插入的任务数量
        """
        print("\n--- 插入示例任务数据 ---")
        tasks = [
            Task(title="任务1", description="这是任务1的描述", priority=1),
            Task(title="任务2", description="这是任务2的描述", priority=2),
            Task(title="任务3", description="这是任务3的描述", priority=3),
            Task(title="任务4", description="这是任务4的描述", priority=4),
            Task(title="任务5", description="这是任务5的描述", priority=5),
        ]
        return self.task_repository.insert_many(tasks)
    
    def insert_single_task(self, task: Task) -> Optional[int]:
        """插入单个任务
        
        Args:
            task: 要插入的任务对象
            
        Returns:
            Optional[int]: 插入的任务ID，失败则返回None
        """
        return self.task_repository.insert_task(task)
    
    def find_all_tasks(self) -> List[Task]:
        """查询所有任务
        
        Returns:
            List[Task]: 任务列表
        """
        return self.task_repository.find_all_tasks()
    
    def find_task_by_id(self, task_id: int) -> Optional[Task]:
        """根据ID查询任务
        
        Args:
            task_id: 任务ID
            
        Returns:
            Optional[Task]: 任务对象，未找到则返回None
        """
        return self.task_repository.find_task_by_id(task_id)
    
    def find_tasks_by_criteria(self, criteria: dict) -> List[Task]:
        """根据条件查询任务
        
        Args:
            criteria: 查询条件字典
            
        Returns:
            List[Task]: 符合条件的任务列表
        """
        return self.task_repository.find_by_criteria(criteria)
    
    def find_tasks_by_title(self, title_part: str) -> List[Task]:
        """根据标题模糊查询任务
        
        Args:
            title_part: 标题包含的文本
            
        Returns:
            List[Task]: 符合条件的任务列表
        """
        return self.task_repository.find_by_title_contains(title_part)
    
    def update_task(self, task: Task) -> bool:
        """更新任务
        
        Args:
            task: 要更新的任务对象
            
        Returns:
            bool: 更新是否成功
        """
        return self.task_repository.update_task(task)
    
    def delete_task(self, task_id: int) -> bool:
        """删除任务
        
        Args:
            task_id: 要删除的任务ID
            
        Returns:
            bool: 删除是否成功
        """
        return self.task_repository.delete_task(task_id)
    
    def close(self) -> None:
        """关闭数据库连接"""
        self.db_manager.close()
if __name__ == '__main__':
    # 实例化示例类
    print('\033[1;36m===== 初始化 SQLite 示例 =====\033[0m')
    sqlite_example = SQLiteExample()
    
    # 插入示例任务数据
    print('\033[1;32m===== 插入示例任务数据 =====\033[0m')
    sqlite_example.insert_sample_tasks()
    
    # 查询所有任务
    print('\033[1;34m===== 查询所有任务 =====\033[0m')
    tasks = sqlite_example.find_all_tasks()
    for task in tasks:
        print('\033[0;37m' + str(task.to_dict()) + '\033[0m')
    
    # 查询单个任务
    print('\033[1;34m===== 查询单个任务 (ID=1) =====\033[0m')
    task = sqlite_example.find_task_by_id(1)
    print('\033[0;33m' + str(task.to_dict()) + '\033[0m')
    
    # 查询任务列表
    print('\033[1;34m===== 查询高优先级任务 (priority=3) =====\033[0m')
    tasks = sqlite_example.find_tasks_by_criteria({'priority': 3})
    for task in tasks:
        print('\033[0;35m' + str(task.to_dict()) + '\033[0m')
    
    # 查询任务标题包含某些字符的任务
    print('\033[1;34m===== 查询标题包含"任务"的任务 =====\033[0m')
    tasks = sqlite_example.find_tasks_by_title('任务')
    for task in tasks:
        print('\033[0;36m' + str(task.to_dict()) + '\033[0m')
    
    # 更新任务
    print('\033[1;33m===== 更新任务 (ID=1) =====\033[0m')
    task = Task(task_id=1, title="任务1-更新", description="这是任务1的更新描述", priority=1, is_completed=True)
    sqlite_example.update_task(task)
    
    # 查询更新后的任务
    print('\033[1;34m===== 查询更新后的任务 (ID=1) =====\033[0m')
    task = sqlite_example.find_task_by_id(1)
    print('\033[0;32m' + str(task.to_dict()) + '\033[0m')
    
    # 删除任务
    print('\033[1;31m===== 删除任务 (ID=1) =====\033[0m')
    sqlite_example.delete_task(1)
    
    # 查询删除后的任务
    print('\033[1;34m===== 查询删除后的任务 (ID=1) =====\033[0m')
    task = sqlite_example.find_task_by_id(1)
    print('\033[0;31m' + str(task) + '\033[0m')
    
    # 关闭数据库连接
    print('\033[1;36m===== 关闭数据库连接 =====\033[0m')
    sqlite_example.close()