from fastapi import Depends, APIRouter, status, Query, Path, HTTPException
from internal.models import *
from internal.database import fetch_one, fetch_all, execute_query, response_success, raise_if_exists, raise_if_not_found
from dependencies import get_current_active_user
from datetime import datetime
router = APIRouter(
    prefix="/disburses",
    tags=['支出管理']
)


@router.get("/list/specificdate")
async def disburse_list(days: int):
    select_query = """SELECT DATE(create_at) AS create_date, SUM(disburseprice) AS total_disburseprice
                FROM disburses
                WHERE DATE(create_at) >= DATE_SUB(CURDATE(), INTERVAL %s DAY) -- 一周前的日期
                GROUP BY DATE(create_at)
                ORDER BY create_date ASC;"""
    disburse_list = fetch_all(select_query, (days-1,))
    return response_success(disburse_list, "disburse get list success")


@router.get("/list/classifieddata")
async def classified_list(days: int):
    select_query = """SELECT SUM(d.disburseprice) AS value,t.typename AS name FROM disburses d
            JOIN disbursetypes t ON d.typeid = t.id
            WHERE d.create_at >= DATE_SUB(CURDATE(), INTERVAL %s DAY)
            GROUP BY t.typename
            ;"""
    classified_list = fetch_all(select_query, (days-1,))
    return response_success(classified_list, "disburse get list success")


@router.get("/list/consume")
async def consume_list(days: int):
    current_year = datetime.now().year
    target_year = current_year - days

    select_query = f"""
    SELECT SUM(d.disburseprice) AS data, t.typename AS name, DATE_FORMAT(d.create_at, '%Y-%m') AS date
    FROM disburses d JOIN disbursetypes t ON d.typeid = t.id
    WHERE YEAR(d.create_at) = {target_year}
    GROUP BY t.typename, DATE_FORMAT(d.create_at, '%Y-%m')
    ORDER BY DATE_FORMAT(d.create_at, '%Y-%m');
    """
    consume_list = fetch_all(select_query)
    result = {}
    for entry in consume_list:
        name = entry['name']
        date = entry['date']
        data = entry['data']

        if name not in result:
            result[name] = [0] * 12

        month_index = int(date.split('-')[1]) - 1
        result[name][month_index] = data

    final_result = [{"name": name, "data": data}
                    for name, data in result.items()]
    return response_success(final_result, "disburse get list success")


@router.get("/list/calendar")
async def calendar_list():
    select_query = """
        SELECT t.typename AS NAME, YEAR(d.create_at) AS YEAR, SUM(d.disburseprice) AS total_amount
        FROM disburses d 
        JOIN disbursetypes t ON d.typeid = t.id
        GROUP BY t.typename, YEAR(d.create_at)
        ORDER BY t.typename, YEAR(d.create_at);
    """
    calendar_list = fetch_all(select_query)

    # Initialize dictionaries to store the transformed data
    transformed_data = {}
    years = set()

    # Process each row from the query result
    for row in calendar_list:
        name = row['NAME']
        year = row['YEAR']
        total_amount = row['total_amount']
        
        if name not in transformed_data:
            transformed_data[name] = {}
        
        transformed_data[name][year] = total_amount
        years.add(year)

    # Prepare the final result in the desired format
    sorted_years = sorted(years)  # Sort years in ascending order
    headers = ['name'] + [str(year) for year in sorted_years]  # Create headers

    final_result = [headers]  # Initialize with headers

    for name, year_data in transformed_data.items():
        row = [name]
        for year in sorted_years:
            row.append(year_data.get(year, 0))  # Append data or 0 if not available
        final_result.append(row)
    
    return response_success(final_result, "disburse get list success")