import 'dart:convert';
import 'package:jinja/jinja.dart' as jj;
import 'package:apidash/utils/utils.dart' show getValidRequestUri, requestModelToHARJsonRequest, stripUriParams;
import '../../models/request_model.dart';
import 'package:apidash/consts.dart';

class JavaHttpClientCodeGen {
  final String kTemplateStart = """
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpHeaders;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse.BodyHandlers;

public class JavaHttpClientExample {

    public static void main(String[] args) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
""";
  final String kTemplateUrl = '''

        String url = "{{url}}";

''';

  final String kTemplateUrlQuery = '''

        String url = "{{url}}";
        try {
            URI uri = new URI(url);
            url = uri.resolve("{{params}}").toString();
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }

''';

  String kTemplateRequestBody = '''

        String body = "{{body}}";

''';

  final String kStringRequestStart = """

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
""";

  final String kTemplateRequestEnd = """
                .{{method}}({{body}})
                .build();

        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
        System.out.println(response.statusCode());
        System.out.println(response.body());
    }
}
\n
""";

  String? getCode(
    RequestModel requestModel,
    String defaultUriScheme,
  ) {
    try {
      String result = "";
      bool hasQuery = false;
      bool hasBody = false;
      bool hasJsonBody = false;

      String url = requestModel.url;
      if (!url.contains("://") && url.isNotEmpty) {
        url = "$defaultUriScheme://$url";
      }

      var rec = getValidRequestUri(
        url,
        requestModel.enabledRequestParams,
      );
      Uri? uri = rec.$1;

      if (uri != null) {
        String url = stripUriParams(uri);

        if (uri.hasQuery) {
          var params = uri.queryParameters;
          if (params.isNotEmpty) {
            hasQuery = true;
            var templateParams = jj.Template(kTemplateUrlQuery);
            result += templateParams.render({"url": url, "params": uri.query});
          }
        } 
        
        if(!hasQuery) {
          var templateUrl = jj.Template(kTemplateUrl);
          result += templateUrl.render({"url": url});
        }
        var rM = requestModel.copyWith(url: url);

      var harJson = requestModelToHARJsonRequest(rM, useEnabled: true);

        var method = requestModel.method;
        var requestBody = requestModel.requestBody;
        if (requestModel.isFormDataRequest && requestModel.formDataMapList.isNotEmpty && kMethodsWithBody.contains(method)) {
            var formDataList = requestModel.formDataMapList;
            result += """
            StringBuilder formData = new StringBuilder();
            formData.append(""";

            for (var formDataMap in formDataList) {
              result += '"""${formDataMap['name']}=${formDataMap['value']}&""",';
            }

            result = result.substring(0, result.length - 1);
            result += ");\n";
            hasBody = true;
        } else if (kMethodsWithBody.contains(method) && requestBody != null) {
          var contentLength = utf8.encode(requestBody).length;
          if (contentLength > 0) {
            var templateBody = jj.Template(kTemplateRequestBody);hasBody = true;
            hasJsonBody = requestBody.startsWith("{") && requestBody.endsWith("}");
            if (harJson["postData"]?["text"] != null) {
        result += templateBody
            .render({"body": kEncoder.convert(harJson["postData"]["text"]).substring(1, kEncoder.convert(harJson["postData"]["text"]).length - 1)});
      }
          }
        }

        result = kTemplateStart + result;
        result += kStringRequestStart;

        var headersList = requestModel.enabledRequestHeaders;
        var contentType = requestModel.requestBodyContentType.header;
        if(hasBody && !requestModel.enabledHeadersMap.containsKey('Content-Type')){
          result = """$result                .header("Content-Type", "$contentType")\n""";
        }
        if (headersList != null) {
          var headers = requestModel.enabledHeadersMap;
          if (headers.isNotEmpty) {
            result += getHeaders(headers,hasJsonBody);
          }
        }

        var templateRequestEnd = jj.Template(kTemplateRequestEnd);
        
        if(kMethodsWithBody.contains(method)){
          result += templateRequestEnd.render({
          "method": method.name.toUpperCase(),
          "body": hasBody ? "BodyPublishers.ofString(body)" : "BodyPublishers.noBody()"
        });
        } else {
          result += templateRequestEnd.render({
          "method": method.name.toUpperCase(),
          "body": ""
        });
        }
      }
      return result;
    } catch (e) {
      return null;
    }
  }

  String getHeaders(Map<String, String> headers,hasJsonBody) {
    String result = "";
    for (final k in headers.keys) {
      if(k.toLowerCase() == 'authorization') {
        result = """$result                .header("$k", "${headers[k]}")\n""";
      } else {
        result = """$result                .header("$k", "${headers[k]}")\n""";
      }
    }
    return result;
  }
}