using System;

namespace TeamAAS_VP.Core.Sfis
{
    public class SfisWorkflowService : IDisposable
    {
        private readonly SfisConfig _config;
        private readonly SfisWebServiceClient _client;
        private bool _sessionStarted;

        public event Action<string> OnLog;

        public SfisWorkflowService(SfisConfig config)
        {
            _config = config ?? throw new ArgumentNullException(nameof(config));
            _client = new SfisWebServiceClient(config);
            _client.OnLog += msg => OnLog?.Invoke(msg);
        }

        public bool IsLoggedIn => _client.IsLoggedIn;

        public SfisWorkflowResult ProcessUnit(SfisUnitContext context, bool runInputData, bool runResult)
        {
            if (context == null)
                throw new ArgumentNullException(nameof(context));
            if (string.IsNullOrWhiteSpace(context.Isn))
                return Fail(context, "ISN 不能为空");
            if (!runInputData && !runResult)
                return Fail(context, "未指定 SFIS 流程（过站/上传均未触发）");

            var workflow = new SfisWorkflowResult { Isn = context.Isn };

            try
            {
                if (_config.AutoLogin && !_client.IsLoggedIn)
                {
                    var login = ExecuteStep(workflow, "Login", () => _client.Login());
                    if (!login.IsSuccess)
                        return Fail(workflow, login.Message);
                    _sessionStarted = true;
                }
                else if (!_config.AutoLogin && !_client.IsLoggedIn)
                {
                    return Fail(workflow, "SFIS 未登录，请先登录或启用自动登录");
                }

                var checkRoute = ExecuteStep(workflow, "CheckRoute",
                    () => _client.CheckRoute(context.Isn, _config.CheckRouteType));
                if (!checkRoute.IsSuccess)
                    return Fail(workflow, checkRoute.Message);

                var getVersion = ExecuteStep(workflow, "GetVersion", () => _client.GetVersion(
                    context.Isn, _config.GetVersionType, _config.GetVersionChkData, _config.GetVersionChkData2));
                if (!getVersion.IsSuccess)
                    return Fail(workflow, getVersion.Message);

                if (runInputData)
                {
                    var payload = SfisInputDataBuilder.FromContext(context, _config);
                    string data = SfisInputDataBuilder.Build(payload);
                    OnLog?.Invoke("InputData: " + data.Replace(SfisDelimiters.Field, '|'));
                    var upload = ExecuteStep(workflow, "InputData",
                        () => _client.SendInputData(data, _config.InputDataType));
                    if (!upload.IsSuccess)
                        return Fail(workflow, upload.Message);
                }

                if (runResult)
                {
                    string data = BuildResultData(context);
                    var upload = ExecuteStep(workflow, "SendResult", () => _client.SendResult(
                        context.Isn, data, _config.ResultStatus,
                        context.TestPassed ? null : context.ErrorCode));
                    if (!upload.IsSuccess)
                        return Fail(workflow, upload.Message);
                }

                workflow.Success = true;
                return workflow;
            }
            catch (Exception ex)
            {
                return Fail(workflow, ex.Message);
            }
        }

        public void EnsureLogout()
        {
            if (!_config.AutoLogoutOnExit || !_sessionStarted || !_client.IsLoggedIn)
                return;
            try { _client.Logout(); }
            catch (Exception ex) { OnLog?.Invoke("SFIS 登出失败: " + ex.Message); }
        }

        private static string BuildResultData(SfisUnitContext context)
        {
            if (context.TestRecords != null && context.TestRecords.Count > 0)
                return SfisResultDataBuilder.Build(context.TestRecords);
            return SfisResultDataBuilder.BuildPassOnly(context.Isn, context.TestPassed ? "1" : "0");
        }

        private static SfisResponse ExecuteStep(SfisWorkflowResult workflow, string stepName, Func<SfisResponse> action)
        {
            var response = action();
            workflow.Steps.Add(new SfisWorkflowStepResult { StepName = stepName, Response = response });
            return response;
        }

        private static SfisWorkflowResult Fail(SfisUnitContext context, string message)
        {
            return new SfisWorkflowResult { Isn = context?.Isn, Success = false, ErrorMessage = message };
        }

        private static SfisWorkflowResult Fail(SfisWorkflowResult workflow, string message)
        {
            workflow.Success = false;
            workflow.ErrorMessage = message;
            return workflow;
        }

        public void Dispose()
        {
            EnsureLogout();
        }
    }
}