public static void WriteRawResponseToGeneric()

in src/AutoRest.CSharp/Common/Generation/Writers/ResponseWriterHelpers.cs [18:119]
96 lines of code
17 McCabe index (conditional complexity)

        public static void WriteRawResponseToGeneric(CodeWriter writer, RestClientMethod operation, Output.Models.Responses.Response response, bool async, string? messageVariableName, FormattableString responseVariable)
        {
            var returnType = operation.ReturnType;
            var headersModelType = operation.HeaderModel?.Type;

            ReturnKind kind;

            if (returnType != null && headersModelType != null)
            {
                kind = ReturnKind.HeadersAndValue;
            }
            else if (headersModelType != null)
            {
                kind = ReturnKind.Headers;
            }
            else if (returnType != null)
            {
                kind = ReturnKind.Value;
            }
            else
            {
                kind = ReturnKind.Response;
            }

            var responseBody = response.ResponseBody;
            ReferenceOrConstant value = default;

            var valueVariable = new CodeWriterDeclaration("value");
            switch (responseBody)
            {
                case ObjectResponseBody objectResponseBody:
                    writer.Line($"{responseBody.Type} {valueVariable:D} = default;");
                    writer.WriteDeserializationForMethods(objectResponseBody.Serialization, async, new VariableReference(responseBody.Type, valueVariable), $"{responseVariable}.{Configuration.ApiTypes.ContentStreamName}", objectResponseBody.Type);
                    value = new Reference(valueVariable.ActualName, responseBody.Type);
                    break;
                case StreamResponseBody _:
                    writer.Line($"var {valueVariable:D} = {messageVariableName}.ExtractResponseContent();");
                    value = new Reference(valueVariable.ActualName, responseBody.Type);
                    break;
                case ConstantResponseBody body:
                    writer.Append($"{returnType} {valueVariable:D} = ");
                    writer.WriteReferenceOrConstant(body.Value);
                    writer.Line($";");
                    value = new Reference(valueVariable.ActualName, responseBody.Type);
                    break;
                case StringResponseBody _:
                    var streamReaderVariable = new CodeWriterDeclaration("streamReader");
                    writer.Line($"{typeof(StreamReader)} {streamReaderVariable:D} = new {typeof(StreamReader)}({responseVariable}.{Configuration.ApiTypes.ContentStreamName});");
                    writer.Append($"{returnType} {valueVariable:D} = ");
                    if (async)
                    {
                        writer.Line($"await {streamReaderVariable}.ReadToEndAsync().ConfigureAwait(false);");
                    }
                    else
                    {
                        writer.Line($"{streamReaderVariable}.ReadToEnd();");
                    }
                    value = new Reference(valueVariable.ActualName, responseBody.Type);
                    break;
                default:
                    {
                        if (returnType != null)
                        {
                            value = Constant.Default(returnType.WithNullable(true));
                        }

                        break;
                    }
            }

            switch (kind)
            {
                case ReturnKind.Response:
                    writer.Append($"return {responseVariable};");
                    break;
                case ReturnKind.Headers:
                    writer.Append($"return {typeof(ResponseWithHeaders)}.FromValue(headers, {responseVariable});");
                    break;
                case ReturnKind.HeadersAndValue:
                    writer.Append($"return {typeof(ResponseWithHeaders)}.FromValue");
                    if (!Equals(responseBody?.Type, operation.ReturnType))
                    {
                        writer.Append($"<{operation.ReturnType}, {headersModelType}>");
                    }
                    writer.Append($"(");
                    writer.WriteReferenceOrConstant(value);
                    writer.Append($", headers, {responseVariable});");
                    break;
                case ReturnKind.Value:
                    writer.Append($"return {Configuration.ApiTypes.ResponseType}.FromValue");
                    if (!Equals(responseBody?.Type, operation.ReturnType))
                    {
                        writer.Append($"<{operation.ReturnType}>");
                    }
                    writer.Append($"(");
                    writer.WriteReferenceOrConstant(value);
                    writer.Append($", {responseVariable});");
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }