using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using RevitHttpControl.Models;
using RevitHttpControl.Services;
using RevitHttpControl.Common;

namespace RevitHttpControl.Controllers
{
    /// <summary>
    /// 导出功能控制器
    /// </summary>
    [RoutePrefix("api/export")]
    public class ExportController : ApiController
    {
        /// <summary>
        /// 获取支持的导出格式
        /// </summary>
        /// <returns>支持的格式列表</returns>
        [HttpGet, Route("formats")]
        public HttpResponseMessage GetSupportedFormats()
        {
            try
            {
                var formats = ExportService.GetSupportedFormats();

                var response = new ApiResponse<List<ExportFormat>>
                {
                    Success = true,
                    Code = 200,
                    Message = "获取支持的导出格式成功",
                    Data = formats
                };

                return Request.CreateResponse(HttpStatusCode.OK, response);
            }
            catch (Exception ex)
            {
                var errorResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 500,
                    Message = ErrorMessages.INTERNAL_ERROR_MSG,
                    Data = new
                    {
                        error = ErrorCodes.INTERNAL_ERROR,
                        errorDescription = ex.Message
                    }
                };

                return Request.CreateResponse(HttpStatusCode.InternalServerError, errorResponse);
            }
        }

        /// <summary>
        /// 同步导出IFC格式
        /// </summary>
        /// <param name="request">导出请求参数</param>
        /// <returns>导出结果</returns>
        [HttpPost, Route("ifc")]
        public HttpResponseMessage ExportIfc([FromBody] ExportIfcRequest request)
        {
            try
            {
                // 参数验证
                if (request == null)
                {
                    var badRequestResponse = new ApiResponse<object>
                    {
                        Success = false,
                        Code = 400,
                        Message = ErrorMessages.INVALID_REQUEST_PARAMETERS_MSG,
                        Data = new { error = ErrorCodes.INVALID_REQUEST_PARAMETERS }
                    };
                    return Request.CreateResponse(HttpStatusCode.BadRequest, badRequestResponse);
                }

                // 验证输出路径（如果提供）
                if (!string.IsNullOrWhiteSpace(request.OutputPath))
                {
                    if (!IsValidPath(request.OutputPath))
                    {
                        var pathErrorResponse = new ApiResponse<object>
                        {
                            Success = false,
                            Code = 400,
                            Message = ErrorMessages.EXPORT_PATH_INVALID_MSG,
                            Data = new { error = ErrorCodes.EXPORT_PATH_INVALID }
                        };
                        return Request.CreateResponse(HttpStatusCode.BadRequest, pathErrorResponse);
                    }
                }

                // 执行同步导出
                var result = ExportService.ExportToIfc(request);

                var successResponse = new ApiResponse<ExportIfcResponse>
                {
                    Success = true,
                    Code = 200,
                    Message = "IFC导出成功",
                    Data = result
                };

                return Request.CreateResponse(HttpStatusCode.OK, successResponse);
            }
            catch (InvalidOperationException ex) when (ex.Message.Contains(ErrorMessages.NO_DOCUMENT_OPEN_MSG))
            {
                var noDocResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 409,
                    Message = ErrorMessages.NO_DOCUMENT_OPEN_MSG,
                    Data = new { error = ErrorCodes.NO_DOCUMENT_OPEN }
                };
                return Request.CreateResponse(HttpStatusCode.Conflict, noDocResponse);
            }
            catch (InvalidOperationException ex) when (ex.Message.Contains(ErrorMessages.EXPORT_PATH_ACCESS_DENIED_MSG))
            {
                var accessDeniedResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 403,
                    Message = ErrorMessages.EXPORT_PATH_ACCESS_DENIED_MSG,
                    Data = new { error = ErrorCodes.EXPORT_PATH_ACCESS_DENIED }
                };
                return Request.CreateResponse(HttpStatusCode.Forbidden, accessDeniedResponse);
            }
            catch (TimeoutException ex)
            {
                var timeoutResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 408,
                    Message = ex.Message,
                    Data = new { error = ErrorCodes.OPERATION_TIMEOUT }
                };
                return Request.CreateResponse(HttpStatusCode.RequestTimeout, timeoutResponse);
            }
            catch (Exception ex)
            {
                var errorResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 500,
                    Message = ErrorMessages.IFC_EXPORT_FAILED_MSG,
                    Data = new
                    {
                        error = ErrorCodes.IFC_EXPORT_FAILED,
                        errorDescription = ex.Message
                    }
                };
                return Request.CreateResponse(HttpStatusCode.InternalServerError, errorResponse);
            }
        }

        /// <summary>
        /// 异步导出IFC格式
        /// </summary>
        /// <param name="request">导出请求参数</param>
        /// <returns>异步任务信息</returns>
        [HttpPost, Route("ifc/async")]
        public HttpResponseMessage ExportIfcAsync([FromBody] ExportIfcRequest request)
        {
            try
            {
                // 参数验证
                if (request == null)
                {
                    var badRequestResponse = new ApiResponse<object>
                    {
                        Success = false,
                        Code = 400,
                        Message = ErrorMessages.INVALID_REQUEST_PARAMETERS_MSG,
                        Data = new { error = ErrorCodes.INVALID_REQUEST_PARAMETERS }
                    };
                    return Request.CreateResponse(HttpStatusCode.BadRequest, badRequestResponse);
                }

                // 验证输出路径（如果提供）
                if (!string.IsNullOrWhiteSpace(request.OutputPath))
                {
                    if (!IsValidPath(request.OutputPath))
                    {
                        var pathErrorResponse = new ApiResponse<object>
                        {
                            Success = false,
                            Code = 400,
                            Message = ErrorMessages.EXPORT_PATH_INVALID_MSG,
                            Data = new { error = ErrorCodes.EXPORT_PATH_INVALID }
                        };
                        return Request.CreateResponse(HttpStatusCode.BadRequest, pathErrorResponse);
                    }
                }

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

                // 异步执行导出操作
                ExportService.ExportToIfcAsync(request, taskId.ToString(), TaskManager.Instance);

                var asyncResponse = new AsyncExportResponse
                {
                    TaskId = taskId.ToString(),
                    StatusUrl = $"/api/task/{taskId}",
                    EstimatedCompletionTime = DateTime.Now.AddMinutes(5) // 预估5分钟完成
                };

                var successResponse = new ApiResponse<AsyncExportResponse>
                {
                    Success = true,
                    Code = 202,
                    Message = "IFC导出任务已创建",
                    Data = asyncResponse
                };

                return Request.CreateResponse(HttpStatusCode.Accepted, successResponse);
            }
            catch (Exception ex)
            {
                var errorResponse = new ApiResponse<object>
                {
                    Success = false,
                    Code = 500,
                    Message = ErrorMessages.IFC_EXPORT_FAILED_MSG,
                    Data = new
                    {
                        error = ErrorCodes.IFC_EXPORT_FAILED,
                        errorDescription = ex.Message
                    }
                };
                return Request.CreateResponse(HttpStatusCode.InternalServerError, errorResponse);
            }
        }

        /// <summary>
        /// 验证文件路径是否有效
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <returns>是否有效</returns>
        private bool IsValidPath(string path)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(path))
                    return false;

                // 检查路径格式
                var fullPath = System.IO.Path.GetFullPath(path);
                
                // 检查是否为有效的文件路径
                var directory = System.IO.Path.GetDirectoryName(fullPath);
                var fileName = System.IO.Path.GetFileName(fullPath);

                return !string.IsNullOrWhiteSpace(directory) && 
                       !string.IsNullOrWhiteSpace(fileName) &&
                       fileName.IndexOfAny(System.IO.Path.GetInvalidFileNameChars()) == -1;
            }
            catch
            {
                return false;
            }
        }
    }
}