import json
import os.path
import traceback

import uvicorn
from starlette.middleware.cors import CORSMiddleware
from starlette.responses import FileResponse

from com import log
from com.sharepoint_tool import SharepointTool
import argparse
from fastapi import FastAPI, File, UploadFile, Request

chrome_path = fr"C:\Program Files\Google\Chrome\Application\chrome.exe"
user_data_dir = "user_data_dir"
size = "800,600"
position = "0,0"
always_show = True
page_timeout = 30 * 1000
login_timeout = 5 * 60 * 1000
download_site = None
login_selector = "#login_selector"
login_url = "https://www.office.com/?auth=2"
max_retry_count = 5
retry_interval = 1
output_folder = "output"

if os.path.exists("global.json"):
    config = json.load(open("global.json"))
    if "chrome_path" in config:
        chrome_path = config["chrome_path"]
    if "user_data_dir" in config:
        user_data_dir = config["user_data_dir"]
    if "win_size" in config:
        size = config["win_size"]
    if "win_posi" in config:
        position = config["win_posi"]
    if "always_show" in config:
        always_show = config["always_show"]
    if "page_timeout" in config:
        page_timeout = config["page_timeout"]
    if "login_timeout" in config:
        login_timeout = config["login_timeout"]
    if "download_site" in config:
        download_site = config["download_site"]
    if "login_selector" in config:
        login_selector = config["login_selector"]
    if "login_url" in config:
        login_url = config["login_url"]
    if "max_retry_count" in config:
        max_retry_count = config["max_retry_count"]
    if "retry_interval" in config:
        retry_interval = config["retry_interval"]
    if "output_folder" in config:
        output_folder = config["output_folder"]

app = FastAPI()

# 添加CORS中间件处理跨域问题
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

sharepoint_tool: SharepointTool = None


@app.get("/download")
async def download_file(folder_path, file_name):
    global sharepoint_tool, output_folder
    try:
        sharepoint_tool.print(leval="ERROR",
                              msg=f"recived download request.folder_path: {folder_path} file_name: {file_name}")
        save_file = sharepoint_tool.download_file_by_name(
            folder_path=folder_path,
            file_name=file_name,
            output_folder=f"{output_folder}/files"
        )
        sharepoint_tool.print(leval="ERROR", msg="download finish.")
        return FileResponse(save_file, filename=file_name, media_type="application/octet-stream")
    except:
        sharepoint_tool.print(leval="ERROR", msg=traceback.format_exc())
        return {
            "code": 500,
            "data": traceback.format_exc()
        }


@app.post("/upload")
async def upload_file(params: Request, file: UploadFile = File(...)):
    """
    文件上传, 分类存储到指定位置
    :param params: 用于获取请求的参数和信息
    :param file: 上传的文对象
    :return: {
        "file_type": "",
        "output_name": ""
    }
    """
    try:
        form = dict(await params.form())
        sharepoint_tool.print(leval="ERROR",
                              msg=f"recived upload request.folder_path: {form['folder_path']} file_name: {file.filename}")
        save_path = f"{output_folder}/files"
        if not os.path.exists(save_path):
            os.makedirs(save_path)
        save_file_name = f"{save_path}/{file.filename}"
        # 保存文件
        with open(save_file_name, "wb") as f:
            f.write(await file.read())

        sharepoint_tool.upload_file_to_folder(
            folder_path=form["folder_path"],
            local_file_name=save_file_name
        )
        sharepoint_tool.print(leval="ERROR", msg="upload finish.")
        return {
            "code": 200,
            "data": "OK"
        }
    except:
        sharepoint_tool.print(leval="ERROR", msg=traceback.format_exc())
        return {
            "code": 500,
            "data": traceback.format_exc()
        }

if __name__ == '__main__':
    global sharepoint_tool
    parser = argparse.ArgumentParser(description='manual to this script')
    parser.add_argument("--chrome_path", type=str)
    parser.add_argument("--user_data_dir", type=str)
    parser.add_argument("--win_size", type=str)
    parser.add_argument("--win_posi", type=str)
    parser.add_argument("--always_show", type=str)
    parser.add_argument("--page_timeout", type=int)
    parser.add_argument("--login_timeout", type=int)
    parser.add_argument("--download_site", type=str)
    parser.add_argument("--login_selector", type=str)
    parser.add_argument("--login_url", type=str)
    parser.add_argument("--max_retry_count", type=int)
    parser.add_argument("--retry_interval", type=int)
    parser.add_argument("--output_folder", type=str)
    parser.add_argument("--host", type=str, default="0.0.0.0")
    parser.add_argument("--port", type=int, default=8000)
    args = vars(parser.parse_args())
    if args["chrome_path"] is not None:
        chrome_path = args["chrome_path"]
    if args["user_data_dir"] is not None:
        user_data_dir = args["user_data_dir"]
    if args["win_size"] is not None:
        size = args["win_size"]
    if args["win_posi"] is not None:
        position = args["win_posi"]
    if args["always_show"] is not None:
        always_show = True if args["always_show"] == "true" else False
    if args["page_timeout"] is not None:
        page_timeout = args["page_timeout"]
    if args["login_timeout"] is not None:
        login_timeout = args["login_timeout"]
    if args["download_site"] is not None:
        download_site = args["download_site"]
    if args["login_selector"] is not None:
        login_selector = args["login_selector"]
    if args["login_url"] is not None:
        login_url = args["login_url"]
    if args["max_retry_count"] is not None:
        max_retry_count = args["max_retry_count"]
    if args["retry_interval"] is not None:
        retry_interval = args["retry_interval"]
    if args["output_folder"] is not None:
        output_folder = args["output_folder"]
    log_path = f"{output_folder}/logs"
    if not os.path.exists(log_path):
        os.makedirs(log_path)

    logger = log.init_logger(f"{log_path}/{os.path.basename(__file__).split('.')[0]}.log")

    always_show = False
    sharepoint_tool = SharepointTool(chrome_exec_path=chrome_path,
                                     user_data_dir=user_data_dir,
                                     login_url=login_url,
                                     size=size,
                                     position=position,
                                     always_show=always_show,
                                     page_timeout=page_timeout,
                                     login_timeout=login_timeout,
                                     download_site=download_site,
                                     login_selector=login_selector,
                                     max_retry_count=max_retry_count,
                                     retry_interval=retry_interval,
                                     logger=logger
                                     )
    sharepoint_tool.print(leval="INFO", msg=f'Initialization complete. listining to {args["host"]}:{args["port"]}')
    uvicorn.run(app, host=args["host"], port=args["port"])