using AGVNavigationCore.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AGVNavigationCore.PathFinding.Core
{
    public static class Utility
    {
        /// <summary>
        /// 두 경로 결과를 합치기
        /// 이전 경로의 마지막 노드와 현재 경로의 시작 노드가 같으면 시작 노드를 제거하고 합침
        /// </summary>
        /// <param name="previousResult">이전 경로 결과</param>
        /// <param name="currentResult">현재 경로 결과</param>
        /// <returns>합쳐진 경로 결과</returns>
        public static AGVPathResult CombineResults(AGVPathResult previousResult, AGVPathResult currentResult)
        {
            // 입력 검증
            if (previousResult == null)
                return currentResult;

            if (currentResult == null)
                return previousResult;

            if (!previousResult.Success)
                return AGVPathResult.CreateFailure(
                    $"이전 경로 결과 실패: {previousResult.Message}",
                    previousResult.CalculationTimeMs);

            if (!currentResult.Success)
                return AGVPathResult.CreateFailure(
                    $"현재 경로 결과 실패: {currentResult.Message}",
                    currentResult.CalculationTimeMs);

            // 경로가 비어있는 경우 처리
            if (previousResult.Path == null || previousResult.Path.Count == 0)
                return currentResult;

            if (currentResult.Path == null || currentResult.Path.Count == 0)
                return previousResult;

            // 합친 경로 생성
            var combinedPath = new List<MapNode>(previousResult.Path);
            var combinedCommands = new List<AgvDirection>(previousResult.Commands);
            var combinedDetailedPath = new List<NodeMotorInfo>(previousResult.DetailedPath ?? new List<NodeMotorInfo>());

            // 이전 경로의 마지막 노드와 현재 경로의 시작 노드 비교
            string lastNodeOfPrevious = previousResult.Path[previousResult.Path.Count - 1].Id;
            string firstNodeOfCurrent = currentResult.Path[0].Id;

            if (lastNodeOfPrevious == firstNodeOfCurrent)
            {
                // 첫 번째 노드 제거 (중복 제거)
                combinedPath.RemoveAt(combinedPath.Count - 1);
                combinedPath.AddRange(currentResult.Path);

                // DetailedPath도 첫 번째 노드 제거
                if (currentResult.DetailedPath != null && currentResult.DetailedPath.Count > 0)
                {
                    combinedDetailedPath.RemoveAt(combinedDetailedPath.Count - 1);
                    combinedDetailedPath.AddRange(currentResult.DetailedPath);
                }
            }
            else
            {
                // 그대로 붙임
                combinedPath.AddRange(currentResult.Path);

                // DetailedPath도 그대로 붙임
                if (currentResult.DetailedPath != null && currentResult.DetailedPath.Count > 0)
                {
                    combinedDetailedPath.AddRange(currentResult.DetailedPath);
                }
            }

            // 명령어 합치기
            combinedCommands.AddRange(currentResult.Commands);

            // 총 거리 합산
            float combinedDistance = previousResult.TotalDistance + currentResult.TotalDistance;

            // 계산 시간 합산
            long combinedCalculationTime = previousResult.CalculationTimeMs + currentResult.CalculationTimeMs;

            // 합쳐진 결과 생성
            var result = AGVPathResult.CreateSuccess(
                combinedPath,
                combinedCommands,
                combinedDistance,
                combinedCalculationTime
            );

            // DetailedPath 설정
            result.DetailedPath = combinedDetailedPath;
            result.PrevNode = previousResult.PrevNode;
            result.PrevDirection = previousResult.PrevDirection;

            return result;
        }


    }
}
