zengzy / hhrcs_service · Files

using System.Text.Json;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Rcs.Application.Common;
using Rcs.Application.Shared;
using Rcs.Cyaninetech.Models;
using Rcs.Domain.Settings;

namespace Rcs.Cyaninetech.Services;

/// <summary>
/// LanYin外挂服务实现
/// </summary>
public class LanYinService : ILanYinService
{
    private readonly IHttpClientService _httpClient;
    private readonly ILogger<LanYinService> _logger;
    private readonly LanYinSettings _settings;
    private readonly SemaphoreSlim _loginLock = new SemaphoreSlim(1, 1);

    public LanYinService(
        IHttpClientService httpClient,
        ILogger<LanYinService> logger,
        IOptions<AppSettings> settings)
    {
        _httpClient = httpClient;
        _logger = logger;
        _settings = settings.Value.LanYinSettings;
    }
    public async Task<bool> LoginAsync(
        LanYinLoginRequest request,
        CancellationToken cancellationToken = default)
    {
        try
        {
            _logger.LogInformation(
                "尝试使用账号 {Account} 登录",
                request.account);

            var url = $"{_settings.BaseUrl}{_settings.Endpoints.Login}";

            var response = await _httpClient.PutAsync<LanYinLoginRequest, LanYinResponse<LanYinLoginData>>(
                url,
                request,
                null, // 登录请求不需要认证头
                cancellationToken);

            if (response?.success == true && response.data != null)
            {
                // 自动更新服务的认证令牌和登录凭证
                _settings.AuthToken = response.data.access_token;
                // _settings.Account = _settings.Account;
                // _settings.Password = _settings.Password;
                
                _logger.LogInformation("成功以账号 {Account} 登录", request.account);
                return true;
            }
            else
            {
                var errorId = response?.msg?.detail?.error_id ?? 0;
                var errorInfo = response?.msg?.detail?.info ?? "Unknown error";
                throw new Exception($"[{errorId}]-{errorInfo}");
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(
                ex.Message);

            return false;
        }
    }

    public async Task<List<LanYinLocationData>> GetLocationsAsync(
        string url,
        CancellationToken cancellationToken = default)
    {
        return await ExecuteWithAutoRetryAsync(
            async () =>
            {
                var headers = GetAuthHeaders();

                var response = await _httpClient.GetAsync<LanYinResponse<List<LanYinLocationData>>>(
                    url,
                    headers,
                    cancellationToken);

                if (response?.success == true)
                {
                    return response.data != null ? (List<LanYinLocationData>)response.data : new List<LanYinLocationData>();
                }
                else
                {
                    // 检查是否需要重新登录
                    if (NeedsRelogin(response.msg))
                    {
                        throw new TokenExpiredException("Token已过期或无效");
                    }
                    throw new Exception("获取库位信息失败");
                }
            },
            cancellationToken,
            new List<LanYinLocationData>());
    }
    
    public async Task<ApiResponse<LanYinTaskData>> DispatchTaskAsync(
        LanYinDispatchTaskRequest request,
        CancellationToken cancellationToken = default)
    {
        return await ExecuteWithAutoRetryAsync(
            async () =>
            {
                _logger.LogInformation(
                    "正在将库位 {LocationId} 区域 {Area} 的任务下发到LanYin系统",
                    request.location_id,
                    request.area);
                ApiResponse<LanYinTaskData> res = new ApiResponse<LanYinTaskData>();
                var url = $"{_settings.BaseUrl}{_settings.Endpoints.DispatchTask}";
                var headers = GetAuthHeaders();

                var response = await _httpClient.PutAsync<LanYinDispatchTaskRequest, LanYinResponse<LanYinTaskData>>(
                    url,
                    request,
                    headers,
                    cancellationToken);
                res.Success = response?.success ?? false;
                res.Data = response?.data ?? new LanYinTaskData();
                if (response?.success != true)
                {
                    // 检查是否需要重新登录
                    if (NeedsRelogin(response?.msg))
                    {
                        throw new TokenExpiredException("Token已过期或无效");
                    }
                    res.Message = (response?.msg?.detail.info + response?.msg?.detail?.error_id) ?? "Unknown error";
                }

                return res;
            },
            cancellationToken,
            new ApiResponse<LanYinTaskData>());
    }

    public async Task<LanYinMapInfoData> SyncMapResource(string url, CancellationToken cancellationToken = default)
    {
        return await ExecuteWithAutoRetryAsync(
            async () =>
            {

                var headers = GetAuthHeaders();

                var response = await _httpClient.GetAsync<LanYinResponse<List<LanYinMapInfoData>>>(
                    url,
                    headers,
                    cancellationToken);

                if (response?.success == true)
                {
                    return response.data?.Count > 0 ? response.data[0] : new LanYinMapInfoData();
                }
                else
                {
                    // 检查是否需要重新登录
                    if (NeedsRelogin(response.msg))
                    {
                        throw new TokenExpiredException("Token已过期或无效");
                    }
                    throw new Exception("获取地图资源信息失败");
                }
            },
            cancellationToken,
            new LanYinMapInfoData());
    }


    /// <summary>
    /// 确认工况异常
    /// @author zzy
    /// </summary>
    public async Task<ApiResponse> ConfirmExceptionAsync(string robotId, CancellationToken cancellationToken = default)
    {
        return await ExecuteWithAutoRetryAsync(
            async () =>
            {
                _logger.LogInformation("正在确认工况异常...");
                var headers = GetAuthHeaders();
                var url = $"{_settings.BaseUrl}{_settings.Endpoints.ConfirmException}";
                var response = await _httpClient.PutAsync<LanYinRobotIdRequest, LanYinResponse<object>>(
                    url, 
                    new LanYinRobotIdRequest(){slave_id = robotId}, 
                    headers, 
                    cancellationToken);

                if (response?.success != true)
                {
                    if (NeedsRelogin(response?.msg)) throw new TokenExpiredException("Token已过期或无效");
                    return ApiResponse.Failed($"确认工况异常失败: {response?.msg?.detail?.info}");
                }

                return ApiResponse.Successful();
            },
            cancellationToken,
            ApiResponse.Failed("操作失败"));
    }

    /// <summary>
    /// 取消任务
    /// @author zzy
    /// </summary>
    public async Task<ApiResponse> CancelTaskAsync(CancellationToken cancellationToken = default)
    {
        return await ExecuteWithAutoRetryAsync(
            async () =>
            {
                _logger.LogInformation("正在取消任务...");
                var res = new ApiResponse<bool>();
                var headers = GetAuthHeaders();
                var url = $"{_settings.BaseUrl}{_settings.Endpoints.CancelTask}";
                var response = await _httpClient.PutAsync<object, LanYinResponse<object>>(url, new { }, headers, cancellationToken);

                if (response?.success != true)
                {
                    if (NeedsRelogin(response?.msg)) throw new TokenExpiredException("Token已过期或无效");
                    return ApiResponse.Failed($"取消任务失败: {response?.msg?.detail?.info}");
                }

                return ApiResponse.Successful();
            },
            cancellationToken,
            ApiResponse.Failed("操作失败"));
    }

    /// <summary>
    /// 取消指定机器人的任务
    /// @author zzy
    /// </summary>
    public async Task<ApiResponse> CancelTaskByRobotAsync(string robotId, CancellationToken cancellationToken = default)
    {
        return await ExecuteWithAutoRetryAsync(
            async () =>
            {
                _logger.LogInformation("正在取消机器人 {RobotId} 的任务...", robotId);
                var res = new ApiResponse<bool>();
                var headers = GetAuthHeaders();
                var url = $"{_settings.BaseUrl}{_settings.Endpoints.CancelTask}";
                var response = await _httpClient.PatchAsync<LanYinCancelTaskRequest, LanYinResponse<object>>(
                    url, 
                    new LanYinCancelTaskRequest(){slave_id = robotId}, 
                    headers, 
                    cancellationToken);

                if (response?.success != true)
                {
                    if (NeedsRelogin(response?.msg)) throw new TokenExpiredException("Token已过期或无效");
                    return ApiResponse.Failed($"取消指定机器人的任务失败: {response?.msg?.detail?.info}");
                }

                return ApiResponse.Successful();
            },
            cancellationToken,
            ApiResponse.Failed("操作失败"));
    }

    /// <summary>
    /// 复位指定机器人
    /// @author zzy
    /// </summary>
    public async Task<ApiResponse> ResetRobotAsync(string robotId, CancellationToken cancellationToken = default)
    {
        return await ExecuteWithAutoRetryAsync(
            async () =>
            {
                _logger.LogInformation("正在复位机器人 {RobotId}...", robotId);
                var res = new ApiResponse<bool>();
                var headers = GetAuthHeaders();
                var url = $"{_settings.BaseUrl}{_settings.Endpoints.ResetRobot}";
                var response = await _httpClient.PutAsync<LanYinRobotIdRequest, LanYinResponse<object>>(
                    url,
                    new LanYinRobotIdRequest(){slave_id = robotId},
                    headers,
                    cancellationToken);

                if (response?.success != true)
                {
                    if (NeedsRelogin(response?.msg)) throw new TokenExpiredException("Token已过期或无效");
                    return ApiResponse.Failed($"复位指定机器人的任务失败: {response?.msg?.detail?.info}");
                }

                return ApiResponse.Successful();
            },
            cancellationToken,
            ApiResponse.Failed("操作失败"));
    }

    /// <summary>
    /// 新增库位类型
    /// @author zzy
    /// </summary>
    public async Task<ApiResponse> AddOrEditLocationTypeAsync(LanYinAddLocationTypeRequest request, CancellationToken cancellationToken = default)
    {
        return await ExecuteWithAutoRetryAsync(
            async () =>
            {
                
                var locationTypes = await GetLocationTypesAsync();
                var headers = GetAuthHeaders();
                if (!locationTypes.Any(l => l.type_name.Equals(request.type_name)))
                {
                    _logger.LogInformation("正在新增库位类型 {TypeName}...", request.type_name);
                    
                    var url = $"{_settings.BaseUrl}{_settings.Endpoints.AddLocationType}";
                    var response = await _httpClient.PostAsync<LanYinAddLocationTypeRequest, LanYinResponse<object>>(
                        url,
                        request,
                        headers,
                        cancellationToken);

                    if (response?.success != true)
                    {
                        if (NeedsRelogin(response?.msg)) throw new TokenExpiredException("Token已过期或无效");
                        return ApiResponse.Failed($"新增库位类型失败: {response?.msg?.detail?.info}");
                    }
                }
                else
                {
                    var locationType = locationTypes.First(l => l.type_name.Equals(request.type_name));
                    _logger.LogInformation("正在新编辑位类型 {TypeName}...", request.type_name);
                    var url = $"{_settings.BaseUrl}{_settings.Endpoints.AddLocationType}";
                    var editRequest = new LanYinAddLocationTypeData()
                    {
                        id = locationType.id,
                        type_name = request.type_name,
                        pickup_event_id = request.pickup_event_id,
                        pick_up_deviation = request.pick_up_deviation,
                        stock_event_id = request.stock_event_id,
                        stock_deviation = request.stock_deviation
                    };
                    var response = await _httpClient.PutAsync<LanYinAddLocationTypeData, LanYinResponse<object>>(
                        url,
                        editRequest,
                        headers,
                        cancellationToken);

                    if (response?.success != true)
                    {
                        if (NeedsRelogin(response?.msg)) throw new TokenExpiredException("Token已过期或无效");
                        return ApiResponse.Failed($"编辑库位类型失败: {response?.msg?.detail?.info}");
                    }
                }
                

                return ApiResponse.Successful();
            },
            cancellationToken,
            ApiResponse.Failed("操作失败"));
    }
    
    public async Task<List<LanYinLocationTypeData>> GetLocationTypesAsync(CancellationToken cancellationToken = default)
    {
        return await ExecuteWithAutoRetryAsync(
            async () =>
            {
                var headers = GetAuthHeaders();
                var url = $"{_settings.BaseUrl}{_settings.Endpoints.GetLocationTypes}";
                var response = await _httpClient.GetAsync<LanYinResponse<List<LanYinLocationTypeData>>>(
                    url,
                    headers,
                    cancellationToken);

                if (response?.success == true)
                {
                    return response.data != null ? response.data : new List<LanYinLocationTypeData>();
                }
                else
                {
                    // 检查是否需要重新登录
                    if (NeedsRelogin(response.msg))
                    {
                        throw new TokenExpiredException("Token已过期或无效");
                    }
                    throw new Exception("获取库位信息失败");
                }
            },
            cancellationToken,
            new List<LanYinLocationTypeData>());
    }
    /// <summary>
    /// 执行带自动重试的请求（如果token过期会自动重新登录）
    /// </summary>
    private async Task<T> ExecuteWithAutoRetryAsync<T>(
        Func<Task<T>> operation,
        CancellationToken cancellationToken,
        T defaultValue)
    {
        try
        {
            return await operation();
        }
        catch (TokenExpiredException)
        {
            _logger.LogWarning("Token已过期，尝试重新登录...");

            // 使用信号量确保只有一个线程执行登录
            await _loginLock.WaitAsync(cancellationToken);
            try
            {
                // 检查是否已经由其他线程完成了登录
                if (!string.IsNullOrWhiteSpace(_settings.Account) && 
                    !string.IsNullOrWhiteSpace(_settings.Password))
                {
                    var loginRequest = new LanYinLoginRequest
                    {
                        account = _settings.Account,
                        password = _settings.Password
                    };

                    var loginSuccess = await LoginAsync(loginRequest, cancellationToken);
                    
                    if (loginSuccess)
                    {
                        _logger.LogInformation("重新登录成功，重试原始请求...");
                        
                        // 重新执行原始操作
                        try
                        {
                            return await operation();
                        }
                        catch (TokenExpiredException)
                        {
                            _logger.LogError("重新登录后仍然失败");
                            return defaultValue;
                        }
                    }
                    else
                    {
                        _logger.LogError("重新登录失败");
                        return defaultValue;
                    }
                }
                else
                {
                    _logger.LogError("无法自动重新登录：未配置账号或密码");
                    return defaultValue;
                }
            }
            finally
            {
                _loginLock.Release();
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "执行请求时发生错误");
            return defaultValue;
        }
    }

    /// <summary>
    /// 检查响应是否表示需要重新登录
    /// </summary>
    private bool NeedsRelogin(ResMessage? msg)
    {
        if (msg?.detail?.error_id == null)
            return false;

        var errorId = msg.detail?.error_id;
        return errorId == 51050008 || errorId == 51050006;
    }

    private Dictionary<string, string> GetAuthHeaders()
    {
        var headers = new Dictionary<string, string>();

        if (!string.IsNullOrWhiteSpace(_settings.ApiKey))
        {
            headers.Add("X-API-Key", _settings.ApiKey);
        }

        if (!string.IsNullOrWhiteSpace(_settings.AuthToken))
        {
            headers.Add("Authorization", $"Bearer {_settings.AuthToken}");
        }

        return headers;
    }

    public async Task<ApiResponse> PauseRobotAsync(string robotId, CancellationToken cancellationToken = default)
    {
        return await ExecuteWithAutoRetryAsync(
            async () =>
            {
                _logger.LogInformation("正在暂停机器人 {RobotId} ...", robotId);
                var res = new ApiResponse<bool>();
                var headers = GetAuthHeaders();
                var url = $"{_settings.BaseUrl}{_settings.Endpoints.RobotPause}";
                var response = await _httpClient.PatchAsync<LanYinCancelTaskRequest, LanYinResponse<object>>(
                    url, 
                    new LanYinCancelTaskRequest(){slave_id = robotId}, 
                    headers, 
                    cancellationToken);

                if (response?.success != true)
                {
                    if (NeedsRelogin(response?.msg)) throw new TokenExpiredException("Token已过期或无效");
                    return ApiResponse.Failed($"暂停机器人失败: {response?.msg?.detail?.info}");
                }

                return ApiResponse.Successful();
            },
            cancellationToken,
            ApiResponse.Failed("操作失败"));
    }

    public async Task<ApiResponse> UnPauseRobotAsync(string robotId, CancellationToken cancellationToken = default)
    {
        return await ExecuteWithAutoRetryAsync(
            async () =>
            {
                _logger.LogInformation("正在取消暂停机器人 {RobotId} ...", robotId);
                var res = new ApiResponse<bool>();
                var headers = GetAuthHeaders();
                var url = $"{_settings.BaseUrl}{_settings.Endpoints.RobotUnPause}";
                var response = await _httpClient.PatchAsync<LanYinCancelTaskRequest, LanYinResponse<object>>(
                    url, 
                    new LanYinCancelTaskRequest(){slave_id = robotId}, 
                    headers, 
                    cancellationToken);

                if (response?.success != true)
                {
                    if (NeedsRelogin(response?.msg)) throw new TokenExpiredException("Token已过期或无效");
                    return ApiResponse.Failed($"取消暂停机器人失败: {response?.msg?.detail?.info}");
                }

                return ApiResponse.Successful();
            },
            cancellationToken,
            ApiResponse.Failed("操作失败"));
    }

    /// <summary>
    /// 重定位机器人
    /// @author zzy
    /// </summary>
    public async Task<ApiResponse> RelocateRobotAsync(string robotId,int scene_id, double x, double y, double theta, CancellationToken cancellationToken = default)
    {
        return await ExecuteWithAutoRetryAsync(
            async () =>
            {
                _logger.LogInformation("正在重定位机器人 {RobotId} 到 ({X}, {Y}, {Theta})...", robotId, x, y, theta);
                var headers = GetAuthHeaders();
                var url = $"{_settings.BaseUrl}{_settings.Endpoints.RelocateRobot}";
                var request = new LanYinReLocationRequest
                {
                    slave_id = robotId,
                    scene_id = scene_id,
                    position = new LanYinReLocationPosition()
                    {
                        x = (float)x,
                        y = (float)y,
                        rad = (float)theta
                    }
                };
                var response = await _httpClient.PutAsync<LanYinReLocationRequest, LanYinResponse<object>>(
                    url,
                    request,
                    headers,
                    cancellationToken);

                if (response?.success != true)
                {
                    if (NeedsRelogin(response?.msg)) throw new TokenExpiredException("Token已过期或无效");
                    return ApiResponse.Failed($"重定位机器人失败: {response?.msg?.detail?.info}");
                }

                return ApiResponse.Successful();
            },
            cancellationToken,
            ApiResponse.Failed("操作失败"));
    }
}

/// <summary>
/// Token过期异常
/// </summary>
internal class TokenExpiredException : Exception
{
    public TokenExpiredException(string message) : base(message) { }
}