using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using UdpClientLib;
using UnityEngine;

/// <summary>
/// 어플리케이션의 핵심 비즈니스 로직과 데이터를 관리하는 모델 클래스
/// 로봇 제어기와의 TCP/UDP 통신을 담당하며, 로봇의 상태 조회, 이동 명령 전송, 
/// 프로그램(Job) 파일의 생성/수정/삭제/실행 기능을 수행
/// </summary>
/// 
public class ProgramModel
{
    private string tcpBaseUrl;
    private string udpBaseUrl;
    HttpClient httpClient = new HttpClient();
    private SingleTcpClient tcpClient;
    private SingleUdpClient udpClient;
    public UdpClientManager manager = new UdpClientManager();

    // --- 데이터 캐시 ---
    private List<JobInfoDTO> allProgramsCache = new List<JobInfoDTO>(); // 로봇에 저장된 프로그램 목록 캐시
    public RobotProgram CurrentProgram { get; private set; } // 현재 로드된 프로그램 정보
    private RobotData robotData;

    // --- 동기화 및 상태 변수 ---
    private readonly object lockObject = new object(); // 스레드 간 데이터 접근 동기화를 위한 락 객체
    private bool hasNewData; // 새 데이터 수신 여부 플래그

    public bool IsMoving; // 현재 로봇이 이동 중인지 여부
    public bool isError; // 현재 로봇이 에러 상태인지 여부

    private Vector3 startMovementPosition; // 이동 시작 전 목표 위치 (UDP 패킷 검증용)
    private int currentToolNum = 0; // 현재 로봇에 설정된 툴 번호

    public bool isMoveAllowed = true; // 통신 허용 여부 플래그
    public event Action<bool> OnRobotErrorStateChanged; // 에러 상태 변경 시 알림을 주기 위한 이벤트

    /// <summary>
    /// 생성자: 통신 URL을 설정하고 비동기 연결 작업을 시작
    /// </summary>
    public ProgramModel(string hostip, int tcpPort, int udpPort, RobotController robotController)
    {
        tcpBaseUrl = $"http://{hostip}:{tcpPort}";
        udpBaseUrl = $"http://{hostip}:{udpPort}";
        _ = HandleAsyncWork(hostip, tcpPort, udpPort);
    }

    /// <summary>
    /// TCP 및 UDP 클라이언트를 초기화하고 연결
    /// </summary>
    public async Task HandleAsyncWork(string hostip, int tcpPort, int udpPort)
    {
        tcpClient = new SingleTcpClient();
        await tcpClient.ConnectAsync("Tcp-Client", hostip, tcpPort);
        udpClient = manager.AddClient("Udp-client", hostip, udpPort);
        manager.PrintStatus();
    }

    /// <summary>
    /// 어플리케이션 시작 시 필요한 초기 데이터를 로드
    /// (프로그램 목록, 툴 번호 등)
    /// </summary>
    public async Task InitializeAsync()
    {
        await LoadAllPrograms();
        hasNewData = true;
        IsMoving = false;
        isError = false;

        try
        {
            currentToolNum = await GetRobotToolNum();
        }
        catch (Exception e)
        {
            Debug.LogWarning($"현재 툴 번호를 가져오는 데 실패했습니다: {e.Message}. 기본값(0)을 사용합니다.");
            currentToolNum = 1;
        }

        return;
    }

    /// <summary>
    /// UI(ProgramPresenter)에서 최신 로봇 데이터가 있는지 확인할 때 사용
    /// </summary>
    public bool IsNewDataAvailable()
    {
        return robotData != null;
    }

    /// <summary>
    /// 백그라운드 스레드에서 갱신된 최신 로봇 데이터를 안전하게 가져옴
    /// </summary>
    public RobotData GetLatestRobotData()
    {
        lock (lockObject)
        {
            //hasNewData = false; // 데이터를 읽었으므로 플래그를 내림 (최적화를 위해 주석 처리됨: 언제든 읽을 수 있게 함)
            return robotData;
        }
    }

    /// <summary>
    /// 프로그램 생성/불러오기 시스템
    /// </summary>

    public async Task<bool> CheckProgramExists(string jobProgramName)
    {
        string requestUri = $"{tcpBaseUrl}/file_manager/file_exist?pathname=project/jobs/{jobProgramName}";
        HttpResponseMessage result = await httpClient.GetAsync(requestUri);
        string jsonResponse = await result.Content.ReadAsStringAsync();

        return jsonResponse.Equals("true");
    }

    public async Task<bool> CreateNewProgram(string userInputId)
    {
        string robotModelName;

        if (string.IsNullOrEmpty(userInputId)) return false;

        string newProgramId = $"{userInputId}.job";

        if (await CheckProgramExists(newProgramId))
        {
            Debug.LogError("파일이 이미 존재합니다.");
            return false;
        }
        else
            Debug.Log($"{newProgramId} 생성");

        try
        {
            robotModelName = await GetRobotModelNameAsync();
        }
        catch (Exception e)
        {
            Debug.LogError($"로봇 모델명을 가져오는 데 실패했습니다: {e.Message}");
            return false;
        }

        NewJobRequestDTO newJob = new NewJobRequestDTO
        {
            fname = newProgramId,
            model_name = robotModelName,
            n_add_ax = 0
        };

        string jsonString = JsonConvert.SerializeObject(newJob);
        HttpContent jsonPayload = new StringContent(jsonString, Encoding.UTF8, "application/json");

        string requestUri = $"{tcpBaseUrl}/project/jobs/create_job";
        try
        {
            HttpResponseMessage result = await httpClient.PostAsync(requestUri, jsonPayload);
            if (result.IsSuccessStatusCode)
            {
                await LoadProgram(newProgramId);
                object payload = CmdLinePayload("end", 0);
                jsonString = JsonConvert.SerializeObject(payload);
                jsonPayload = new StringContent(jsonString, Encoding.UTF8, "application/json");

                HttpResponseMessage jsonResponse = await httpClient.PostAsync(
                    $"{tcpBaseUrl}/project/jobs/{CurrentProgram.ProgramId}/ins_cmd_line", jsonPayload);
                if (jsonResponse.IsSuccessStatusCode) 
                    return true;
                else 
                    return false;
            }
            else
                return false;
        }
        catch (Exception e)
        {
            Debug.LogError($"프로그램 생성 실패: {userInputId}, {e.Message}");
            return false;
        }
    }

    private async Task<string> GetRobotModelNameAsync()
    {
        string requestUri = $"{tcpBaseUrl}/project/rgen";

        HttpResponseMessage result = await httpClient.GetAsync(requestUri);
        string jsonResponse = await result.Content.ReadAsStringAsync();

        JObject data = JObject.Parse(jsonResponse);

        string modelName = (string)data.SelectToken("robot_model");

        if (string.IsNullOrEmpty(modelName))
        {
            throw new Exception("로봇 상태 API 응답에서 모델명을 찾을 수 없습니다.");
        }

        return modelName;
    }

    public async Task<bool> GetRobotMotorStateAsync()
    {
        string requestUri = $"{tcpBaseUrl}/project/rgen";

        HttpResponseMessage result = await httpClient.GetAsync(requestUri);
        string jsonResponse = await result.Content.ReadAsStringAsync();

        JObject data = JObject.Parse(jsonResponse);

        int motorState = (int)data.SelectToken("enable_state");
        if (motorState == 0 || motorState == 256)
            return true;
        else if (motorState == 1)
            return false;
        else
        {
            throw new Exception("로봇 상태 API 응답에서 모터 상태를 찾을 수 없습니다.");
        }
    }

    public async Task<int> GetRobotToolNum()
    {
        string requestUri = $"{tcpBaseUrl}/project/rgen";

        HttpResponseMessage result = await httpClient.GetAsync(requestUri);
        string jsonResponse = await result.Content.ReadAsStringAsync();

        JObject data = JObject.Parse(jsonResponse);

        int toolNum = (int)data.SelectToken("tool_no");

        return toolNum;
    }

    /// <summary>
    /// [백그라운드 루프 1] TCP를 통해 로봇의 현재 좌표를 주기적으로 조회
    /// </summary>
    public async Task GetTCPAsync(CancellationToken token)
    {
        while (!token.IsCancellationRequested)
        {
            try
            {
                string requestUri = $"{tcpBaseUrl}/project/robot/po_cur";

                HttpResponseMessage result = await httpClient.GetAsync(requestUri);
                string jsonResponse = await result.Content.ReadAsStringAsync();

                var tempRobotData = JsonConvert.DeserializeObject<RobotData>(jsonResponse, new JsonSerializerSettings { CheckAdditionalContent = false });

                lock (lockObject)
                {
                    robotData = tempRobotData;
                    hasNewData = true;
                }
                await Task.Delay(10, token);
            }
            catch (Exception e)
            {
                Debug.Log(e);
                await Task.Delay(1000); // 에러 시 더 긴 대기
            }
        }
    }

    /// <summary>
    /// 서버에서 특정 프로그램의 내용을 로드하여 CurrentProgram에 저장
    /// </summary>
    public async Task<bool> LoadProgram(string programId)
    {
        string requestUri = $"{tcpBaseUrl}/file_manager/files?pathname=project/jobs/{programId}&common";

        HttpResponseMessage result = await httpClient.GetAsync(requestUri);
        string rawTextContent = await result.Content.ReadAsStringAsync();

        if (string.IsNullOrEmpty(rawTextContent))
        {
            return false;
        }

        CurrentProgram = new RobotProgram(programId, rawTextContent);
        
        return true;
    }

    /// <summary>
    /// 서버에 저장된 모든 Job 프로그램 목록을 가져와 캐시
    /// </summary>
    private async Task LoadAllPrograms()
    {
        allProgramsCache.Clear();
        string jsonResponse = null;
        string wrappedJson = null;

        try
        {
            HttpResponseMessage result = await httpClient.GetAsync($"{tcpBaseUrl}/project/jobs_info");
            jsonResponse = await result.Content.ReadAsStringAsync();

            wrappedJson = $"{{\"jobs\":{jsonResponse}}}";
            JobListWrapper wrapper = JsonUtility.FromJson<JobListWrapper>(wrappedJson);

            if (wrapper != null && wrapper.jobs != null)
            {
                allProgramsCache = wrapper.jobs;
            }
            else
            {
                Debug.LogError("서버에서 job 목록을 파싱할 수 없습니다: " + jsonResponse);
            }
        }
        catch (ArgumentException e)
        {
            Debug.LogError($"JSON 파싱 오류: {e.Message}");
        }
        catch (Exception e)
        {
            Debug.LogError($"LoadAllPrograms 알 수 없는 오류: {e.Message}");
        }
    }

    public async Task<List<string>> GetAllProgramIds()
    {
        await LoadAllPrograms();
        List<string> ids = new List<string>();
        foreach (var jobInfo in allProgramsCache)
        {
            ids.Add(jobInfo.fname);
        }
        return ids;
    }

    /// <summary>
    /// 로봇 위치 기록 시스템
    /// </summary>
    
    // 프로그램에 명령문 추가
    public object CmdLinePayload(string cmd_line, int sno_ref)
    {
        object payload;
        if (cmd_line == "end")
        {
            payload = new
            {
                cmd_line = cmd_line,
                sno_ref = sno_ref
            };
        }
        else
        {
            payload = new
            {
                adjust_branch = true,
                cmd_line = cmd_line,
                fno_ref = -1,
                mechinfo = -1,
                move_cursor = 1,
                ofs = 0,
                save_file = true,
                set_cur_pose = 1,
                sno_ref = sno_ref
            };
        }
        return payload;
    }

    /// <summary>
    /// 현재 로봇의 위치를 프로그램의 스텝으로 저장하거나, 기존 스텝을 수정
    /// index가 -1이면 추가, 0 이상이면 해당 인덱스의 스텝 수정
    /// </summary>
    public async Task<bool> SavePointToProgramAsync(RobotData pointData, int index = -1)
    {
        if (CurrentProgram == null)
        {
            Debug.LogError("저장할 프로그램이 로드되지 않았습니다.");
            return false;
        }

        string jsonPayload;
        string requestUri;
        HttpContent content;
        object payload;

        try
        {
            if (index == -1)
            {
                // sno_ref = 마지막 스텝의 번호, 없으면 0
                int sno_ref = (CurrentProgram.Steps.Count > 0) ? CurrentProgram.Steps.Last().StepNumber : 0;

                payload = CmdLinePayload($"move P,spd=50%,accu=3,tool={currentToolNum}", sno_ref);

                requestUri = $"{tcpBaseUrl}/project/jobs/{CurrentProgram.ProgramId}/ins_cmd_line";
            }
            else
            {
                // sno = 수정할 스텝의 번호
                int sno = CurrentProgram.Steps[index].StepNumber;

                payload = new
                {
                    mechinfo = -1,
                    save_file = true,
                    sno = sno
                };

                requestUri = $"{tcpBaseUrl}/project/jobs/{CurrentProgram.ProgramId}/pose_modify";
            }

            jsonPayload = JsonConvert.SerializeObject(payload);
            content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");

            HttpResponseMessage result = await httpClient.PostAsync(requestUri, content);

            if (result.IsSuccessStatusCode)
            {
                // 서버 저장이 성공하면, 로컬 캐시에도 반영
                if (index == -1)
                    CurrentProgram.AddStep(pointData, currentToolNum); // 로컬 캐시에 추가
                else
                    CurrentProgram.UpdateStep(index, pointData); // 로컬 캐시 수정

                return true;
            }

            Debug.LogError($"SavePointToProgramAsync 실패: {await result.Content.ReadAsStringAsync()}");
            return false;
        }
        catch (Exception e)
        {
            Debug.LogError($"포인트 저장 실패: {e.Message}");
            return false;
        }
    }

    /// <summary>
    /// 프로그램에서 특정 스텝을 삭제
    /// </summary>
    public async Task<bool> DeletePointFromProgramAsync(int index)
    {
        if (CurrentProgram == null || index < 0 || index >= CurrentProgram.Steps.Count)
        {
            Debug.LogError($"DeletePointFromProgramAsync: 잘못된 인덱스 {index}");
            return false;
        }

        // sno_ref = 삭제할 스텝의 번호 (0-based index가 아님)
        int sno_ref = CurrentProgram.Steps[index].StepNumber;

        var payload = new
        {
            adjust_branch = true,
            fno_ref = 0,
            ofs = 0,
            save_file = true,
            sno_ref = sno_ref
        };
        string jsonPayload = JsonConvert.SerializeObject(payload);
        HttpContent content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");

        string requestUri = $"{tcpBaseUrl}/project/jobs/{CurrentProgram.ProgramId}/del_cmd_line";

        try
        {
            HttpResponseMessage result = await httpClient.PostAsync(requestUri, content);
            if (result.IsSuccessStatusCode)
            {
                // 서버 삭제 성공 시, 로컬 캐시에서도 삭제 및 재정렬
                CurrentProgram.DeleteStep(index);
                return true;
            }

            Debug.LogError($"DeletePointFromProgramAsync 실패: {await result.Content.ReadAsStringAsync()}");
            return false;
        }
        catch (Exception e)
        {
            Debug.LogError($"포인트 삭제 실패: {e.Message}");
            return false;
        }
    }

    // 타겟 포지션으로 이동
    public async Task<bool> MoveToPoseTcpAsync(Vector3 position)
    {
        //await clientLock.WaitAsync();
        if (!isMoveAllowed)
        {
            Debug.Log("TCP 전송 중단");
            return false;
        }

        try
        {
            startMovementPosition.x = Convert.ToSingle(Math.Round(-1 * position.x * 1000, 2));
            startMovementPosition.y = Convert.ToSingle(Math.Round(-1 * position.z * 1000, 2));
            startMovementPosition.z = Convert.ToSingle(Math.Round(position.y * 1000, 2));

            float currentRx = -180f;
            float currentRy = 0f;
            float currentRz = 180f;

            string jsonResponse = await tcpClient.SendPostRequestAsync("/project/robot/move_to_pose_manual", 
                $"{{\"pose_tg\":{{\"crd\":\"robot\",\"_type\":\"Pose\",\"mechinfo\":1,\"x\":{startMovementPosition.x},\"y\":{startMovementPosition.y},\"z\":{startMovementPosition.z}, \"rx\":{currentRx}, \"ry\":{currentRy}, \"rz\":{currentRz}}}}}");

            if (jsonResponse.Contains("200"))
            {
                Debug.Log("TCP POST (Move) 명령 전송 성공");
                IsMoving = true;
                return true;
            }
            else
            {
                Debug.LogError($"TCP POST (Move) 실패");
                return false;
            }
        }
        catch (TaskCanceledException)
        {
            Debug.Log("TCP 요청이 에러로 인해 취소.");
            return false;
        }
        catch (Exception e)
        {
            Debug.Log($"MoveToPoseTcpAsync 오류: {e.Message}");
            return false;
        }
        finally
        {
            //clientLock.Release();
        }
    }

    // TCP POST 이동 명령 체크
    public async Task StartMovementCheckLoopAsync(CancellationToken token)
    {
        if (!isMoveAllowed)
        {
            Debug.Log("udp패킷 전송 중단");
            return;
        }
        while (!token.IsCancellationRequested)
        {
            try
            {
                if (IsMoving)
                {
                    await udpClient.SendFilledBytesAsync(new Dictionary<int, byte> { { 2, 0x20 } });
                    await Task.Delay(10);

                    RobotData currentPose = null;
                    lock (lockObject) { currentPose = this.robotData; }

                    Vector3 targetPos = startMovementPosition;
                    Vector3 currentPos = new Vector3(Convert.ToSingle(currentPose.x), Convert.ToSingle(currentPose.y), Convert.ToSingle(currentPose.z));

                    if (Vector3.Distance(targetPos, currentPos) < 0.1f)
                    {
                        IsMoving = false;
                    }
                }
                else
                {
                    await Task.Delay(10, token);
                }
            }
            catch (TaskCanceledException)
            {
                Debug.Log("MovementCheckLoopAsync Canceled.");
            }
            catch (Exception e)
            {
                Debug.LogError($"MovementCheckLoopAsync Error: {e.Message}\n{e.StackTrace}");
            }
        }
    }

    //타겟 포지션이 로봇 이동 범위 초과시 에러 처리
    public async Task GetMovementState(CancellationToken token)
    {
        while (!token.IsCancellationRequested)
        {
            try
            {
                var jsonResponse = await tcpClient.SendGetRequestAsync("/project/rgen");
                var pasrsingJsonResponse = HttpResponseParser.ExtractJsonFromHttpResponse(jsonResponse);
                var tempRobotData = JsonConvert.DeserializeObject<RobotStateData>(pasrsingJsonResponse, new JsonSerializerSettings { CheckAdditionalContent = false });

                jsonResponse = await tcpClient.SendGetRequestAsync($"/logManager/search?cat_p=E&id_min={Convert.ToInt32(tempRobotData.eid_last_err) - 3}&id_max={tempRobotData.eid_last_err}");
                pasrsingJsonResponse = HttpResponseParser.ExtractJsonFromHttpResponse(jsonResponse);
                tempRobotData = JsonConvert.DeserializeObject<RobotStateData>(pasrsingJsonResponse, new JsonSerializerSettings { CheckAdditionalContent = false });

                bool newErrorState = tempRobotData != null && tempRobotData.code != null && (tempRobotData.code.Contains("228") || tempRobotData.code.Contains("6037"));
                if (this.isError != newErrorState)
                {
                    this.isError = newErrorState;
                    OnRobotErrorStateChanged?.Invoke(this.isError);
                    //Debug.Log($"[이동범위] 이동 가능 상태: {newErrorState}");
                }

                await Task.Delay(10);
            }
            catch (System.Exception)
            {
            }
        }
    }

    public void SetLocalErrorState(bool state)
    {
        this.isError = state;
        OnRobotErrorStateChanged?.Invoke(this.isError);
    }

    // 이동 중 판단
    public async Task<string> GetMovingState()
    {
        string jsonResponse = await tcpClient.SendGetRequestAsync("/project/robot/moving_to_pose_manual");
        string parsingJsonResponse = HttpResponseParser.ExtractJsonFromHttpResponse(jsonResponse);

        return parsingJsonResponse;
    }


    /// <summary>
    /// 프로그램 정보 패널
    /// </summary>
    
    public async Task<bool> ResetProgram()
    {
        int jobProgramLines = CurrentProgram.Steps.Count + 1;
        var payload = new
        {
            idx_st = 1,
            n_line = jobProgramLines,
            save_file = true
        };
        string jsonPayload = JsonConvert.SerializeObject(payload);
        HttpContent content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");

        string requestUri = $"{tcpBaseUrl}/project/jobs/{CurrentProgram.ProgramId}/del_cmd_lines";

        try
        {
            HttpResponseMessage result = await httpClient.PostAsync(requestUri, content);
            if (result.IsSuccessStatusCode)
            {
                // 서버 삭제 성공 시, 로컬 캐시에서도 전부 삭제
                CurrentProgram.ResetSteps();
                // 다시 end문 추가
                object endPayload = CmdLinePayload("end", 0);
                string endJsonString = JsonConvert.SerializeObject(endPayload);
                HttpContent endContent = new StringContent(endJsonString, Encoding.UTF8, "application/json");
                string endRequestUri = $"{tcpBaseUrl}/project/jobs/{CurrentProgram.ProgramId}/ins_cmd_line";

                HttpResponseMessage endResponse = await httpClient.PostAsync(endRequestUri, endContent);

                if (endResponse.IsSuccessStatusCode)
                {
                    return true;
                }
                else
                {
                    Debug.LogError($"ResetProgramAsync: 'end' 명령어 추가 실패: {await endResponse.Content.ReadAsStringAsync()}");
                    return false;
                }
            }

            Debug.LogError($"ResetProgramAsync 실패: {await result.Content.ReadAsStringAsync()}");
            return false;
        }
        catch (Exception e)
        {
            Debug.LogError($"프로그램 리셋 실패: {e.Message}");
            return false;
        }
    }

    public async Task startProgram()
    {
        string requestUri = $"{tcpBaseUrl}/project/robot/start";
        HttpContent content = new StringContent("{}", Encoding.UTF8, "application/json");

        try
        {
            HttpResponseMessage result = await httpClient.PostAsync(requestUri, content);
            if (result.IsSuccessStatusCode)
            {
                Debug.Log("프로그램 재생");
            }
        }
        catch (Exception e)
        {
            Debug.LogError($"프로그램 재생 실패: {e.Message}");
        }
    }

    public async Task stopProgram()
    {
        string requestUri = $"{tcpBaseUrl}/project/robot/stop";
        HttpContent content = new StringContent("{}", Encoding.UTF8, "application/json");

        try
        {
            HttpResponseMessage result = await httpClient.PostAsync(requestUri, content);
            if (result.IsSuccessStatusCode)
            {
                Debug.Log("프로그램 정지");
            }
        }
        catch (Exception e)
        {
            Debug.LogError($"프로그램 정지 실패: {e.Message}");
        }
    }

    public async Task setProgramSpeed(int spdRate)
    {
        var payload = new
        {
            type = 1,
            val = spdRate
        };
        string jsonPayload = JsonConvert.SerializeObject(payload);
        HttpContent content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");

        string requestUri = $"{tcpBaseUrl}/project/control/op_cnd/set_playback_spd_rate";

        try
        {
            HttpResponseMessage result = await httpClient.PostAsync(requestUri, content);
            if (result.IsSuccessStatusCode)
            {
                Debug.Log("재생 속도 변경");
            }
        }
        catch (Exception e)
        {
            Debug.LogError($"재생 속도 변경 실패: {e.Message}");
        }
    }
}