using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Newtonsoft.Json;
using UnityEngine;

public class OrderProcessor
{
    private readonly PathVisualizer pathVisualizer;
    private readonly PathMover pathMover;
    private readonly Transform transform;
    private string currentMapId;
    private readonly string serialNumber;
    private string lastNodeId;
    private string orderId;
    private int lastNodeSequenceId;
    private OrderData currentOrder;
    private readonly Queue<OrderData> orderQueue;
    private bool isProcessingOrder;

    public OrderProcessor(PathVisualizer pathVisualizer, PathMover pathMover, Transform transform,
        string initialMapId, string serialNumber)
    {
        this.pathVisualizer = pathVisualizer;
        this.pathMover = pathMover;
        this.transform = transform;
        this.currentMapId = initialMapId;
        this.serialNumber = serialNumber;
        this.lastNodeId = null;
        this.orderId = null;
        this.lastNodeSequenceId = 0;
        this.currentOrder = null;
        this.orderQueue = new Queue<OrderData>();
        this.isProcessingOrder = false;

        if (pathMover != null)
        {
            pathMover.OnMoveCompleted += OnMoveCompleted;
        }
    }

    public string CurrentMapId => currentMapId;
    public string LastNodeId => lastNodeId;
    public string OrderId => orderId;
    public int LastNodeSequenceId => lastNodeSequenceId;
    public OrderData CurrentOrder => currentOrder;
    public string SerialNumber => serialNumber;

    public async void ProcessOrderJson(string json)
    {
        try
        {
            OrderData order = await Task.Run(() => JsonConvert.DeserializeObject<OrderData>(json));

            if (order.SerialNumber != serialNumber)
            {
                Debug.LogWarning($"SerialNumber trong JSON ({order.SerialNumber}) không khớp với serialNumber của robot ({serialNumber}).");
                return;
            }

            lock (orderQueue)
            {
                orderQueue.Enqueue(order);
            }

            if (!isProcessingOrder)
            {
                UnityMainThreadDispatcher.Enqueue(() => ProcessNextOrder());
            }
        }
        catch (Exception ex)
        {
            Debug.LogError($"Lỗi khi phân tích JSON: {ex.Message}, SerialNumber: {serialNumber}");
        }
    }

    private void ProcessNextOrder()
    {
        if (isProcessingOrder)
        {
            Debug.Log($"Đang xử lý order, không thể bắt đầu order mới. SerialNumber: {serialNumber}");
            return;
        }

        lock (orderQueue)
        {
            if (orderQueue.Count == 0)
            {
                Debug.Log($"Hàng đợi order trống. SerialNumber: {serialNumber}");
                return;
            }

            isProcessingOrder = true;
            currentOrder = orderQueue.Dequeue();
        }

        orderId = currentOrder.OrderId;

        var lastNode = currentOrder.Nodes.OrderByDescending(n => n.SequenceId).FirstOrDefault();
        lastNodeId = lastNode?.NodeId ?? "";
        lastNodeSequenceId = lastNode?.SequenceId ?? 0;

        string newMapId = currentOrder.Nodes.FirstOrDefault()?.NodePosition.MapId;
        if (!string.IsNullOrEmpty(newMapId))
        {
            currentMapId = newMapId;
        }

        pathVisualizer.DrawPath(currentOrder.Nodes, currentOrder.Edges);
        pathMover.StartMove(currentOrder.Nodes, currentOrder.Edges);
    }

    private void OnMoveCompleted()
    {
        Debug.Log($"Hoàn thành order. OrderId: {orderId}, SerialNumber: {serialNumber}");

        lastNodeId = "";
        orderId = "";
        lastNodeSequenceId = 0;
        currentOrder = null;
        isProcessingOrder = false;

        ProcessNextOrder();
    }

    public void CancelOrder()
    {
        pathMover.CancelMove();
        pathVisualizer.ClearPath();
        lastNodeId = "";
        orderId = "";
        lastNodeSequenceId = 0;
        currentOrder = null;

        lock (orderQueue)
        {
            orderQueue.Clear();
            Debug.Log($"Đã hủy order hiện tại và xóa hàng đợi. SerialNumber: {serialNumber}");
        }

        isProcessingOrder = false;
        Debug.Log($"Đã hủy nhiệm vụ. SerialNumber: {serialNumber}");
    }
}