package nju.seec.SEECdemo.service.api;


import io.kubernetes.client.apis.CoreV1Api;
import io.kubernetes.client.models.V1LimitRange;
import nju.seec.SEECdemo.logic.api.k8s.LimitRangeApi;
import nju.seec.SEECdemo.logic.api.k8s.exception.K8sApiException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.HashMap;
import java.util.Map;


@RunWith(SpringRunner.class)
@SpringBootTest
public class LimitRangeTest {


    @Autowired
    private CoreV1Api coreV1Api;

    @Autowired
    private LimitRangeApi limitRangeApi;

    @Test
    public void limitRangeTest() {
        /*V1LimitRangeItem v1LimitRangeItem = new V1LimitRangeItem();
        Map<String, Quantity> defualt = new HashMap<>();
        defualt.put("cpu", new CpuQuantity(100).toQuantity());
        defualt.put("memory", new StorageQuantity(1024).toQuantity());
        Map<String, Quantity> defualtRequest = new HashMap<>();
        defualtRequest.put("cpu", new CpuQuantity(50).toQuantity());
        defualtRequest.put("memory", new StorageQuantity(256).toQuantity());
        Map<String, Quantity> max = new HashMap<>();
        max.put("cpu", new CpuQuantity(100).toQuantity());
        max.put("memory", new StorageQuantity(1024, StorageQuantity.Unit.GB).toQuantity());
        Map<String, Quantity> min = new HashMap<>();
        min.put("cpu", new CpuQuantity(50).toQuantity());
        min.put("memory", new StorageQuantity(256).toQuantity());
        String type = "Container";
        String apiVersion = "v1";
        v1LimitRangeItem = v1LimitRangeItem
                ._default(defualt)
                .defaultRequest(defualtRequest)
                .max(max)
                .min(min)
                .type(type);
        V1ObjectMeta meta = new V1ObjectMeta().name("limit-range-test2").namespace("mjj-test2");
        String kind = "LimitRangeVO";
        V1LimitRange body = new V1LimitRange()
                .apiVersion(apiVersion)
                .kind(kind)
                .metadata(meta)
                .spec(new V1LimitRangeSpec().addLimitsItem(v1LimitRangeItem));
        String namespace = "mjj-test2";*/
        /*try {
            coreV1Api.createNamespacedLimitRange(namespace, body, "OK");
        } catch (ApiException e) {
            System.out.println(e.getResponseBody());
        }*/


        //Test update
        //LimitRangeVO Not Found 404

        /*try {
            String body1 = "{ \"defualt\" : {\"cpu\" : 1, \"memory\": 1024Mi}}";
            coreV1Api.patchNamespacedLimitRange("limit-range-test2", "mjj-test2", body1, "OK");
        } catch (ApiException e) {
            System.out.println(e.getResponseBody());
        }*/


        //Test createLimitRange
        /*String name2 = "limit-range-test3";
        Map<String, Integer> _default = new HashMap<>();
        _default.put("cpu", 100);
        _default.put("memory", 1024);
        Map<String, Integer> defaultrequest = new HashMap<>();
        defaultrequest.put("cpu", 50);
        defaultrequest.put("memory", 512);
        Map<String, Integer> max1 = new HashMap<>();
        max1.put("cpu", 200);
        max1.put("memory", 1024);
        Map<String, Integer> min1 = new HashMap<>();
        min1.put("cpu", 50);
        min1.put("memory", 512);
        String namespace2 = "mjj-test3";
        try {
            limitRangeApi.createLimitRange(namespace, name2, _default, defaultrequest, max1, min1);
        } catch (K8sApiException e) {
            System.out.println(e.getDescription());
        }*/

        //Test delete limitRange
        /*String namespace = "mjj-test2";
        String name = "limit-range-test3";
        try {
            limitRangeApi.deleteLimitRange(namespace, name);
        } catch (K8sApiException e) {
            e.getDescription();
        }*/


        //Test get LimitRangeVO
        /*String namespace = "mjj-test2";
        String name = "limit-range-test2";
        try {
            V1LimitRange v1LimitRange = limitRangeApi.getLimitRangeByName(namespace, name);
            System.out.println(v1LimitRange.getMetadata().getName());
        } catch (K8sApiException e) {
            e.printStackTrace();
        }*/



        //Test update LimitRangeVO
        String namespace = "mjj-test2";
        String name = "limit-range-test2";
        Map<String, Integer> _default = new HashMap<>();
        _default.put("cpu", 100);
        _default.put("memory", 1024);
        Map<String, Integer> defaultrequest = new HashMap<>();
        defaultrequest.put("cpu", 50);
        defaultrequest.put("memory", 512);
        Map<String, Integer> max1 = new HashMap<>();
        max1.put("cpu", 200);
        max1.put("memory", 1024);
        Map<String, Integer> min1 = new HashMap<>();
        min1.put("cpu", 50);
        min1.put("memory", 512);
        V1LimitRange body = limitRangeApi.toLimitRange(namespace, name, _default, defaultrequest, max1, min1);
        try {
            limitRangeApi.updateLimitRange(namespace, name, body);
        } catch (K8sApiException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void testCreateLimitRange() {
        Map<String, Integer> _default = new HashMap<>();
        _default.put("cpu", 100);
        _default.put("memory", 1024);
        V1LimitRange v1LimitRange = limitRangeApi.toLimitRange("demo", "demo", _default, _default, null, null);
        limitRangeApi.createLimitRange("demo", v1LimitRange);
    }
}