Backend-Api/ServiceHost/Areas/Admin/Controllers/TicketController.cs

using _0_Framework.Application;
using AccountManagement.Application.Contracts.Task;
using AccountManagement.Application.Contracts.Ticket;
using AccountManagement.Application.Contracts.TicketAccessAccount;
using CompanyManagment.App.Contracts.Workshop;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using ServiceHost.BaseControllers;

namespace ServiceHost.Areas.Admin.Controllers;

/// <summary>
/// API controller for admin ticket management functionality
/// </summary>
public class TicketController : AdminBaseController
{
    private readonly ITicketApplication _ticketApplication;
    private readonly IWorkshopApplication _workshopApplication;
    private readonly IAuthHelper _authHelper;
    private readonly ITicketAccessAccountApplication _ticketAccessAccountApplication;

    /// <summary>
    /// Initialize a new instance of the TicketController
    /// </summary>
    public TicketController(
        ITicketApplication ticketApplication,
        IWorkshopApplication workshopApplication,
        IAuthHelper authHelper,
        ITicketAccessAccountApplication ticketAccessAccountApplication)
    {
        _ticketApplication = ticketApplication;
        _workshopApplication = workshopApplication;
        _authHelper = authHelper;
        _ticketAccessAccountApplication = ticketAccessAccountApplication;
    }

    private bool HasTicketAccess()
    {
        return _ticketAccessAccountApplication.HasTicketAccess(_authHelper.CurrentAccountId());
    }

    /// <summary>
    /// Get ticket overview including types count and trash count
    /// </summary>
    /// <param name="searchModel">Search criteria for tickets</param>
    /// <returns>Ticket overview data including counts by type</returns>
    [HttpGet]
    public IActionResult GetTickets([FromQuery] TicketSearchModel searchModel)
    {
        if (!HasTicketAccess())
            return Forbid();

        var typesCount = _ticketApplication.GetTypesCountOfTicketForAdmin();
        var trashCount = _ticketApplication.GetDeletedTicket().Count();

        return Ok(new
        {
            success = true,
            data = new
            {
                typesCount,
                trashCount
            }
        });
    }

    /// <summary>
    /// Get paginated ticket data with filtering options
    /// </summary>
    /// <param name="pageIndex">Page index for pagination (default: 1)</param>
    /// <param name="status">Filter by ticket status</param>
    /// <param name="ticketNumber">Filter by ticket number</param>
    /// <param name="generalSearch">General search term</param>
    /// <returns>Paginated list of tickets matching the criteria</returns>
    [HttpGet("data")]
    public IActionResult GetTicketData([FromQuery] int pageIndex = 1, [FromQuery] string status = "", 
        [FromQuery] string ticketNumber = "", [FromQuery] string generalSearch = "")
    {
        if (!HasTicketAccess())
            return Forbid();

        var searchModel = new TicketSearchModel()
        {
            PageIndex = pageIndex,
            Status = status,
            TicketNumber = generalSearch,
            GeneralSearch = generalSearch,
        };

        List<TicketViewModel> tickets;
        tickets = status != "زباله" ? _ticketApplication.GetAll(searchModel) : _ticketApplication.GetDeletedTicket();

        return Ok(new
        {
            success = true,
            data = tickets,
            pageIndex = tickets.Count
        });
    }

    /// <summary>
    /// Get detailed information about a specific ticket
    /// </summary>
    /// <param name="ticketId">The ID of the ticket to retrieve</param>
    /// <returns>Detailed ticket information including workshop name</returns>
    [HttpGet("{ticketId}/detail")]
    public IActionResult GetTicketDetail(long ticketId)
    {
        if (!HasTicketAccess())
            return Forbid();

        var ticket = _ticketApplication.GetDetails(ticketId);
        if (ticket == null)
            return NotFound();

        ticket.WorkshopName = _workshopApplication.GetDetails(ticket.WorkshopId).WorkshopFullName;

        return Ok(new
        {
            success = true,
            data = ticket
        });
    }

    /// <summary>
    /// Get all messages for a specific ticket
    /// </summary>
    /// <param name="ticketId">The ID of the ticket</param>
    /// <returns>Ticket details including all messages</returns>
    [HttpGet("{ticketId}/messages")]
    public IActionResult GetTicketMessages(long ticketId)
    {
        if (!HasTicketAccess())
            return Forbid();

        var ticketDetail = _ticketApplication.GetDetails(ticketId);
        if (ticketDetail == null)
            return NotFound();

        return Ok(new
        {
            success = true,
            data = ticketDetail
        });
    }

    /// <summary>
    /// Submit an admin response to a ticket
    /// </summary>
    /// <param name="command">Response details including ticket ID and response text</param>
    /// <returns>Operation result indicating success or failure</returns>
    [HttpPost("response")]
    public IActionResult SaveAdminResponse([FromBody] ResponseTicket command)
    {
        if (!HasTicketAccess())
            return Forbid();

        command.AdminId = _authHelper.CurrentAccountId();
        command.Response = command.Response?.Replace("\n", "<br>");

        var result = _ticketApplication.AdminResponseTicket(command);
            
        return Ok(new
        {
            success = result.IsSuccedded,
            message = result.Message
        });
    }

    /// <summary>
    /// Upload a media file for ticket
    /// </summary>
    /// <param name="media">The file to upload</param>
    /// <returns>Upload result with file ID if successful</returns>
    [HttpPost("upload")]
    public IActionResult UploadFile(IFormFile media)
    {
        if (!HasTicketAccess())
            return Forbid();

        var accountId = _authHelper.CurrentAccountId();
        var operation = _ticketApplication.UploadMedia(media, accountId);
            
        return Ok(new
        {
            success = operation.IsSuccedded,
            message = operation.Message,
            id = operation.SendId,
        });
    }

    /// <summary>
    /// Delete a media file from the system
    /// </summary>
    /// <param name="mediaId">The ID of the media file to delete</param>
    /// <returns>Operation result indicating success or failure</returns>
    [HttpDelete("media/{mediaId}")]
    public IActionResult DeleteFile(long mediaId)
    {
        if (!HasTicketAccess())
            return Forbid();

        var operation = _ticketApplication.RemoveMedia(mediaId);
            
        return Ok(new
        {
            success = operation.IsSuccedded,
            message = operation.Message,
        });
    }

    /// <summary>
    /// Remove all temporary uploaded files for the current user
    /// </summary>
    /// <returns>Operation result indicating success</returns>
    [HttpDelete("temp-files")]
    public IActionResult RemoveAllTempFiles()
    {
        if (!HasTicketAccess())
            return Forbid();

        var accId = _authHelper.CurrentAccountId();
        _ticketApplication.RemoveTempUploadedFiles(accId);
            
        return Ok(new
        {
            success = true,
            message = "فایل‌های موقت با موفقیت حذف شدند"
        });
    }

    /// <summary>
    /// Assign a task from a ticket to specific users
    /// </summary>
    /// <param name="request">Task assignment details including description, title, and assignees</param>
    /// <returns>Operation result indicating success or failure</returns>
    [HttpPost("assign-task")]
    public IActionResult AssignTask([FromBody] CreateTaskRequest request)
    {
        if (!HasTicketAccess())
            return Forbid();

        var command = new CreateTask
        {
            SenderId = _authHelper.CurrentAccountId(),
            Description = request.Description?.Replace("\n", "<br>"),
            Title = request.Title,
            EndTaskDate = request.EndTaskDate,
            EndTaskTime = request.EndTaskTime,
            ReceiverId = request.ReceiverId ?? new List<long>(),
            PositionId = request.PositionId ?? new List<long>(),
            UploadedMedia = request.UploadedMedia ?? new List<long>()
        };

        var result = _ticketApplication.AssignTicket(command, request.TicketId);
            
        return Ok(new
        {
            success = result.IsSuccedded,
            message = result.Message,
        });
    }

    /// <summary>
    /// Download or view a file from the system
    /// </summary>
    /// <param name="filePath">The file path on the server</param>
    /// <param name="id">The file ID for naming purposes</param>
    /// <returns>File content for download or viewing</returns>
    [HttpGet("file")]
    public IActionResult GetFile([FromQuery] string filePath, [FromQuery] long id)
    {
        if (!HasTicketAccess())
            return Forbid();

        if (string.IsNullOrEmpty(filePath) || !System.IO.File.Exists(filePath))
            return NotFound();

        var contentType = Tools.GetContentTypeImage(Path.GetExtension(filePath));
        if (string.IsNullOrWhiteSpace(contentType))
        {
            byte[] fileContent = System.IO.File.ReadAllBytes(filePath);
            var extension = Tools.GetContentType(Path.GetExtension(filePath));
            return File(fileContent, extension, $"Task_{id}{Path.GetExtension(filePath)}");
        }
        else
        {
            return PhysicalFile(filePath, contentType);
        }
    }

    /// <summary>
    /// Download or play a voice file
    /// </summary>
    /// <param name="filePath">The voice file path on the server</param>
    /// <returns>Voice file content as audio/ogg</returns>
    [HttpGet("voice")]
    public IActionResult GetVoice([FromQuery] string filePath)
    {
        if (!HasTicketAccess())
            return Forbid();

        if (string.IsNullOrEmpty(filePath) || !System.IO.File.Exists(filePath))
            return NotFound();

        byte[] voiceContent = System.IO.File.ReadAllBytes(filePath);
        return File(voiceContent, "audio/ogg", "Task_voice.ogg");
    }

    /// <summary>
    /// View a picture file
    /// </summary>
    /// <param name="filePath">The image file path on the server</param>
    /// <returns>Image file content</returns>
    [HttpGet("picture")]
    public IActionResult GetPicture([FromQuery] string filePath)
    {
        if (!HasTicketAccess())
            return Forbid();

        if (string.IsNullOrEmpty(filePath) || !System.IO.File.Exists(filePath))
            return NotFound();

        var contentType = Tools.GetContentTypeImage(Path.GetExtension(filePath));
        return PhysicalFile(filePath, contentType);
    }

    /// <summary>
    /// Accept a pending admin response
    /// </summary>
    /// <param name="adminResId">The ID of the admin response to accept</param>
    /// <returns>Operation result indicating success or failure</returns>
    [HttpPost("response/{adminResId}/accept")]
    public IActionResult AcceptPendingAdminResponse(long adminResId)
    {
        if (!HasTicketAccess())
            return Forbid();

        var result = _ticketApplication.AcceptPendingAdminResponse(adminResId);
            
        return Ok(new
        {
            success = result.IsSuccedded,
            message = result.Message
        });
    }

    /// <summary>
    /// Reject a pending admin response
    /// </summary>
    /// <param name="adminResId">The ID of the admin response to reject</param>
    /// <returns>Operation result indicating success or failure</returns>
    [HttpPost("response/{adminResId}/reject")]
    public IActionResult RejectPendingAdminResponse(long adminResId)
    {
        if (!HasTicketAccess())
            return Forbid();

        var result = _ticketApplication.RejectPendingAdminResponse(adminResId);
            
        return Ok(new
        {
            success = result.IsSuccedded,
            message = result.Message
        });
    }

    /// <summary>
    /// Edit and accept a pending admin response
    /// </summary>
    /// <param name="adminResId">The ID of the admin response to edit</param>
    /// <param name="request">The new response text</param>
    /// <returns>Operation result indicating success or failure</returns>
    [HttpPut("response/{adminResId}")]
    public IActionResult EditPendingAdminResponse(long adminResId, [FromBody] EditResponseRequest request)
    {
        if (!HasTicketAccess())
            return Forbid();

        var result = _ticketApplication.EditAndAcceptPendingAdminResponse(adminResId, request.NewResponse.Replace("\n", "<br>"));
            
        return Ok(new
        {
            success = result.IsSuccedded,
            message = result.Message
        });
    }

    /// <summary>
    /// Close a ticket (mark as closed)
    /// </summary>
    /// <param name="ticketId">The ID of the ticket to close</param>
    /// <returns>Operation result indicating success or failure</returns>
    [HttpPost("{ticketId}/close")]
    public IActionResult CloseTicket(long ticketId)
    {
        if (!HasTicketAccess())
            return Forbid();

        var result = _ticketApplication.CloseTicket(ticketId);
            
        return Ok(new
        {
            success = result.IsSuccedded,
            message = result.Message
        });
    }

    /// <summary>
    /// Delete a ticket (move to trash)
    /// </summary>
    /// <param name="ticketId">The ID of the ticket to delete</param>
    /// <returns>Operation result indicating success or failure</returns>
    [HttpDelete("{ticketId}")]
    public IActionResult DeleteTicket(long ticketId)
    {
        if (!HasTicketAccess())
            return Forbid();

        var result = _ticketApplication.DeleteTicket(ticketId);
            
        return Ok(new
        {
            success = result.IsSuccedded,
            message = result.Message
        });
    }

    /// <summary>
    /// Get current ticket counts by status (open, closed, answered, pending, etc.)
    /// </summary>
    /// <returns>Ticket counts grouped by status</returns>
    [HttpGet("counts")]
    public IActionResult GetTicketCounts()
    {
        if (!HasTicketAccess())
            return Forbid();

        var typesCount = _ticketApplication.GetTypesCountOfTicketForAdmin();
        var deletedCount = _ticketApplication.GetDeletedTicket().Count();

        return Ok(new
        {
            success = true,
            data = new
            {
                open = typesCount.Open,
                closed = typesCount.Closed,
                answered = typesCount.Answered,
                pending = typesCount.Pending,
                all = typesCount.All,
                deleted = deletedCount
            }
        });
    }

    /// <summary>
    /// Restore a deleted ticket from trash
    /// </summary>
    /// <param name="ticketId">The ID of the ticket to restore</param>
    /// <returns>Operation result indicating success or failure</returns>
    [HttpPost("{ticketId}/restore")]
    public IActionResult RestoreDeletedTicket(long ticketId)
    {
        if (!HasTicketAccess())
            return Forbid();

        var result = _ticketApplication.RestoreDeletedTicket(ticketId);
            
        return Ok(new
        {
            success = result.IsSuccedded,
            message = result.Message
        });
    }

    /// <summary>
    /// Check if the current user has access to ticket functionality
    /// </summary>
    /// <returns>Access status for the current user</returns>
    [HttpGet("access")]
    public IActionResult CheckTicketAccess()
    {
        var accountId = _authHelper.CurrentAccountId();
        var hasAccess = _ticketAccessAccountApplication.HasTicketAccess(accountId);

        return Ok(new
        {
            success = true,
            hasAccess
        });
    }
}

/// <summary>
/// Request model for creating and assigning tasks from tickets
/// </summary>
public class CreateTaskRequest
{
    /// <summary>
    /// Task description
    /// </summary>
    public string Description { get; set; }
        
    /// <summary>
    /// Task title
    /// </summary>
    public string Title { get; set; }
        
    /// <summary>
    /// Task end date
    /// </summary>
    public string EndTaskDate { get; set; }
        
    /// <summary>
    /// Task end time
    /// </summary>
    public string EndTaskTime { get; set; }
        
    /// <summary>
    /// List of receiver IDs for task assignment
    /// </summary>
    public List<long> ReceiverId { get; set; }
        
    /// <summary>
    /// List of position IDs for task assignment
    /// </summary>
    public List<long> PositionId { get; set; }
        
    /// <summary>
    /// List of uploaded media file IDs
    /// </summary>
    public List<long> UploadedMedia { get; set; }
        
    /// <summary>
    /// The ticket ID to assign task from
    /// </summary>
    public long TicketId { get; set; }
}

/// <summary>
/// Request model for editing admin responses
/// </summary>
public class EditResponseRequest
{
    /// <summary>
    /// The new response text
    /// </summary>
    public string NewResponse { get; set; }
}