from fastapi import APIRouter, Request, Depends, HTTPException, Query, Response
from sqlalchemy.exc import IntegrityError

from fastapi.responses import JSONResponse
from database import get_db
from sqlalchemy.orm import Session
from models import *
import json
import random
from sqlalchemy import create_engine, select, or_
from typing import Optional
import uuid
from utils import *
from common.security import valid_access_token
import traceback
from sqlalchemy import text, exists
router = APIRouter()

def get_next_yjbh_id(db: Session):
    while True:
        random_10_digit_number = random.randint(1000000000, 9999999999)
        yjbhId = 'YHBZ' + str(random_10_digit_number)

        it_exists = db.query(
            exists().where(TaskRegistration.task_id == yjbhId)
        ).scalar()

        if it_exists == False:
            return yjbhId


@router.post('/create')
async def create_task(
        request: Request,
        db: Session = Depends(get_db),
        body=Depends(remove_xss_json),
        user_id=Depends(valid_access_token)):
    try:
        # 验证必需的字段
        required_fields = ['standard_type', 'file_title']
        missing_fields = [field for field in required_fields if field not in body]
        if missing_fields:
            raise HTTPException(status_code=401, detail=f"Missing required fields: {', '.join(missing_fields)}")



        fileList = []
        if 'fileList' in body:
            fileList = body['fileList']
            del body['fileList']

        standard_type = body['standard_type']
        file_title = body['file_title']
        for file in fileList:
            print(file)
            create_time = file["create_time"]
            file_name = file['url']
            file_name_desc = file['name']
            status = file['status']
            new_file = HazardStandardsFile(
                file_id=new_guid(),
                # foreign_key=task_base.id,
                file_number=get_next_yjbh_id(db),
                from_scenario='task_file',
                file_name=file_name,
                standard_type=standard_type,
                file_title=file_title,
                file_name_desc=file_name_desc,
                status=status,
                create_time =create_time
            )
            db.add(new_file)
            db.commit()
            print(new_file)
        return {
            "code": 200,
            "msg": "succeed",
            "data": file_title
        }

    except Exception as e:
        db.rollback()
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")


# 删除文件接口
@router.delete('/delete')
async def delete_file(  body=Depends(remove_xss_json),
        user_id=Depends(valid_access_token),
                        db: Session = Depends(get_db)                ):
    try:
        # 查询要删除的文件
        file_id = body.get("file_id")
        hazard_file = db.query(HazardStandardsFile).filter(HazardStandardsFile.file_id == file_id).first()

        # 如果文件不存在，返回404错误
        if hazard_file is None:
            raise HTTPException(status_code=404, detail="File not found")

        # 如果文件已经被删除，返回错误信息
        if hazard_file.del_flag == '2':
            raise HTTPException(status_code=400, detail="File already deleted")

        # 更新删除标识
        hazard_file.del_flag = '2'
        hazard_file.update_time = datetime.now()

        # 提交更改到数据库
        db.commit()

        return {
            "code": 200,
            "msg": "File marked as deleted",
            "data": file_id
        }

    except Exception as e:
        db.rollback()
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")




# 查询文件接口
@router.post('/select')
@router.get('/select')
async def select_files(
        db: Session = Depends(get_db),
        file_title: str = Query(None, description="文件标题"),
        standard_type: str = Query(None, description="标准类型"),
        # sortBy: str = Query(None, description="排序字段"),
        # sortOrder: str = Query(None, description="排序顺序"),
        pageNum: int = Query(1, gt=0, description="页码"),
        pageSize: int = Query(10, gt=0, le=100, description="每页大小")):
    try:
        data_query = db.query(HazardStandardsFile).filter(HazardStandardsFile.del_flag != '2')


        # 应用过滤条件
        # if file_title:
        #     data_query = data_query.filter(HazardStandardsFile.file_title == file_title)

        if file_title:
            data_query = data_query.filter(HazardStandardsFile.file_title.like(f'%{file_title}%'))

        if standard_type:
            data_query = data_query.filter(HazardStandardsFile.standard_type == standard_type)

        # # 应用排序条件
        # if sortBy:
        #     if hasattr(HazardStandardsFile, sortBy):
        #         sort_attr = getattr(HazardStandardsFile, sortBy)
        #         data_query = data_query.order_by(sort_attr.asc() if sortOrder == 'asc' else sort_attr.desc())

        total_count = data_query.count()
        offset = (pageNum - 1) * pageSize
        data_query = data_query.offset(offset).limit(pageSize)

        rows = data_query.all()
        data = []
        for row in rows:
            info = {
                "file_id": row.file_id,
                "file_number": row.file_number,
                "file_name": row.file_name,
                "standard_type": row.standard_type,
                "file_name_desc": row.file_name_desc,
                "file_title": row.file_title,
                "create_time": row.create_time.strftime("%Y-%m-%d %H:%M:%S")  # 格式化日期时间
            }
            data.append(info)

        return {
            "code": 200,
            "msg": "文件查询成功",
            "data": data,
            "total": total_count,
            "pages": (total_count + pageSize - 1) // pageSize,
            "current_page": pageNum,
            "page_size": pageSize
        }

    except Exception as e:
        db.rollback()
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")