using System;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using RevitHttpControl.Models;
using RevitHttpControl.Services;

namespace RevitHttpControl.Controllers
{
    /// <summary>
    /// 文件操作控制器
    /// </summary>
    [RoutePrefix("api")]
    public class FileController : ApiController
    {
        /// <summary>
        /// 打开文件
        /// </summary>
        /// <param name="request">打开文件请求</param>
        /// <returns>打开文件响应</returns>
        [HttpPost]
        [Route("open")]
        public HttpResponseMessage OpenFile([FromBody] OpenFileRequest request)
        {
            try
            {
                // 参数验证
                if (request == null)
                {
                    var badRequestResponse = new ApiResponse<object>
                    {
                        Success = false,
                        Code = 400,
                        Message = "请求参数不能为空",
                        Data = new { error = "INVALID_REQUEST" }
                    };
                    return Request.CreateResponse(HttpStatusCode.BadRequest, badRequestResponse);
                }

                if (string.IsNullOrWhiteSpace(request.FilePath))
                {
                    var badRequestResponse = new ApiResponse<object>
                    {
                        Success = false,
                        Code = 400,
                        Message = "文件路径不能为空",
                        Data = new { error = "INVALID_FILE_PATH" }
                    };
                    return Request.CreateResponse(HttpStatusCode.BadRequest, badRequestResponse);
                }

                // 验证文件路径
                if (!DocumentService.ValidateFilePath(request.FilePath))
                {
                    var notFoundResponse = new ApiResponse<object>
                    {
                        Success = false,
                        Code = 404,
                        Message = "文件不存在或路径无效",
                        Data = new { error = "FILE_NOT_FOUND" }
                    };
                    return Request.CreateResponse(HttpStatusCode.NotFound, notFoundResponse);
                }

                // 同步打开文件
                var result = DocumentService.OpenDocument(request);

                var successResponse = new ApiResponse<OpenFileResponse>
                {
                    Success = true,
                    Code = 200,
                    Message = "文件打开成功",
                    Data = result
                };

                return Request.CreateResponse(HttpStatusCode.OK, successResponse);
            }
            catch (ArgumentException ex)
            {
                var badRequestResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 400,
                    Message = ex.Message,
                    Data = new { error = "INVALID_ARGUMENT" }
                };
                return Request.CreateResponse(HttpStatusCode.BadRequest, badRequestResponse);
            }
            catch (System.IO.FileNotFoundException ex)
            {
                var notFoundResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 404,
                    Message = ex.Message,
                    Data = new { error = "FILE_NOT_FOUND" }
                };
                return Request.CreateResponse(HttpStatusCode.NotFound, notFoundResponse);
            }
            catch (TimeoutException ex)
            {
                var timeoutResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 408,
                    Message = ex.Message,
                    Data = new { error = "OPERATION_TIMEOUT" }
                };
                return Request.CreateResponse(HttpStatusCode.RequestTimeout, timeoutResponse);
            }
            catch (Exception ex)
            {
                var errorResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 500,
                    Message = "打开文件时发生错误",
                    Data = new
                    {
                        error = "INTERNAL_ERROR",
                        errorDescription = ex.Message
                    }
                };
                return Request.CreateResponse(HttpStatusCode.InternalServerError, errorResponse);
            }
        }

        /// <summary>
        /// 异步打开文件
        /// </summary>
        /// <param name="request">打开文件请求</param>
        /// <returns>异步任务响应</returns>
        [HttpPost]
        [Route("open/async")]
        public HttpResponseMessage OpenFileAsync([FromBody] OpenFileRequest request)
        {
            try
            {
                // 参数验证
                if (request == null || string.IsNullOrWhiteSpace(request.FilePath))
                {
                    var badRequestResponse = new ApiResponse<object>
                    {
                        Success = false,
                        Code = 400,
                        Message = "请求参数无效",
                        Data = new { error = "INVALID_REQUEST" }
                    };
                    return Request.CreateResponse(HttpStatusCode.BadRequest, badRequestResponse);
                }

                // 创建异步任务
                var taskId = TaskManager.Instance.CreateTask(request.ExecutionId);
                TaskManager.Instance.SetTaskRunning(taskId);

                // 异步执行打开文件操作
                DocumentService.OpenDocumentAsync(request, taskId, TaskManager.Instance);

                var asyncResponse = new AsyncOperationResponse
                {
                    TaskId = taskId,
                    StatusUrl = $"/api/task/{taskId}"
                };

                var successResponse = new ApiResponse<AsyncOperationResponse>
                {
                    Success = true,
                    Code = 202,
                    Message = "文件打开任务已创建",
                    Data = asyncResponse
                };

                return Request.CreateResponse(HttpStatusCode.Accepted, successResponse);
            }
            catch (Exception ex)
            {
                var errorResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 500,
                    Message = "创建异步任务失败",
                    Data = new
                    {
                        error = "INTERNAL_ERROR",
                        errorDescription = ex.Message
                    }
                };
                return Request.CreateResponse(HttpStatusCode.InternalServerError, errorResponse);
            }
        }

        /// <summary>
        /// 关闭当前打开文件
        /// </summary>
        /// <returns>关闭文件响应</returns>
        [HttpPost]
        [Route("close")]
        public HttpResponseMessage CloseFile()
        {
            try
            {
                var result = DocumentService.CloseCurrentDocument();

                var successResponse = new ApiResponse<CloseFileResponse>
                {
                    Success = true,
                    Code = 200,
                    Message = "文件关闭成功",
                    Data = result
                };

                return Request.CreateResponse(HttpStatusCode.OK, successResponse);
            }
            catch (InvalidOperationException ex)
            {
                var errorCode = "NO_DOCUMENT_OPEN";
                if (ex.Message.Contains("文档切换未生效") ||
                    ex.Message.Contains("无法切换到可关闭目标") ||
                    ex.Message.IndexOf("active document", StringComparison.OrdinalIgnoreCase) >= 0)
                {
                    errorCode = "ACTIVE_DOCUMENT_CANNOT_CLOSE";
                }
                else if (ex.Message.Contains("目标文档未找到"))
                {
                    errorCode = "TARGET_NOT_FOUND";
                }

                var conflictResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 409,
                    Message = ex.Message,
                    Data = new { error = errorCode }
                };
                return Request.CreateResponse(HttpStatusCode.Conflict, conflictResponse);
            }
            catch (TimeoutException ex)
            {
                var timeoutResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 408,
                    Message = ex.Message,
                    Data = new { error = "OPERATION_TIMEOUT" }
                };
                return Request.CreateResponse(HttpStatusCode.RequestTimeout, timeoutResponse);
            }
            catch (Exception ex)
            {
                var errorResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 500,
                    Message = "关闭文件时发生错误",
                    Data = new
                    {
                        error = "INTERNAL_ERROR",
                        errorDescription = ex.Message
                    }
                };
                return Request.CreateResponse(HttpStatusCode.InternalServerError, errorResponse);
            }
        }
    }
}