package com.casic.missiles.utils;

import com.alibaba.excel.util.StringUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * @Description: 单位转换工具
 * @Author: wangpeng
 * @Date: 2024/1/12 10:54
 */
public class UnitConvertUtil {

    /**
     * 频率单位换算：Hz、kHz、MHz、GHz、THz
     * @param valueOne 需要换算的数值
     * @param valueUnit 需要换算的数值单位
     * @param finalUnit 需要换算后的单位
     * @return 换算后的数据
     */
    public static BigDecimal frequencyConvert(String valueOne, String valueUnit, String finalUnit) {
        BigDecimal value = new BigDecimal(valueOne);
        if (valueUnit.equals(finalUnit)) {
            return value;
        }
        BigDecimal processValue = BigDecimal.ZERO;
        BigDecimal resultValue = BigDecimal.ZERO;
        //1、将valueOne转为Hz对应值
        switch (valueUnit) {
            case "kHz":
                processValue = value.multiply(new BigDecimal("1000"));
                break;
            case "MHz":
                processValue = value.multiply(new BigDecimal("1000000"));
                break;
            case "GHz":
                processValue = value.multiply(new BigDecimal("1000000000"));
                break;
            case "THz":
                processValue = value.multiply(new BigDecimal("1000000000000"));
                break;
            default:
                processValue = value;
                break;
        }
        //2、将valueOne转为finalUnit对应值
        switch (finalUnit) {
            case "kHz":
                resultValue = processValue.divide(new BigDecimal("1000"), 11, RoundingMode.HALF_UP);
                break;
            case "MHz":
                resultValue = processValue.divide(new BigDecimal("1000000"), 7, RoundingMode.HALF_UP);
                break;
            case "GHz":
                resultValue = processValue.divide(new BigDecimal("1000000000"), 9, RoundingMode.HALF_UP);
                break;
            case "THz":
                resultValue = processValue.divide(new BigDecimal("1000000000000"), 12, RoundingMode.HALF_UP);
                break;
            default:
                resultValue = processValue;
                break;
        }
        return resultValue;
    }

    /**
     * 根据数值和单位得到响应保留小数位数后的数值，:kHz保留小数后3位、MHz 保留小数后6位、GHz保留小数后9位、THz保留小数后12位
     * @param valueUnit 单位
     * @param value 待保留小数位数的员数值
     * @return 保留指定小数位数的数值
     */
    public static BigDecimal valueDecimalConvert(String valueUnit, String value) {
        BigDecimal resultValue = new BigDecimal(value);
        switch (valueUnit) {
            case "kHz":
                resultValue = resultValue.setScale(3, RoundingMode.HALF_UP);
                break;
            case "MHz":
                resultValue = resultValue.setScale(6, RoundingMode.HALF_UP);
                break;
            case "GHz":
                resultValue = resultValue.setScale(9, RoundingMode.HALF_UP);
                break;
            case "THz":
                resultValue = resultValue.setScale(12, RoundingMode.HALF_UP);
                break;
            default:
                break;
        }
        return resultValue;
    }

    /**
     * 根据数值和单位得到响应保留小数位数后的数值，:kHz保留小数后11位、MHz 保留小数后7位、GHz保留小数后9位
     * @param valueUnit 单位
     * @param value 待保留小数位数的员数值
     * @return 保留指定小数位数的数值
     */
    public static BigDecimal valueDecimalConvertTwo(String valueUnit, String value) {
        BigDecimal resultValue = new BigDecimal(value);
        switch (valueUnit) {
            case "kHz":
                resultValue = resultValue.setScale(11, RoundingMode.HALF_UP);
                break;
            case "MHz":
                resultValue = resultValue.setScale(7, RoundingMode.HALF_UP);
                break;
            case "GHz":
                resultValue = resultValue.setScale(9, RoundingMode.HALF_UP);
                break;
            default:
                break;
        }
        return resultValue;
    }

    /**
     * 时间单位换算：d、h、min、s、ms、μs、ns、ps
     * @param valueOne 需要换算的数值
     * @param valueUnit 需要换算的数值单位
     * @param finalUnit 需要换算后的单位
     * @return 换算后的数据
     */
    public static BigDecimal timeConvert(String valueOne, String valueUnit, String finalUnit) {
        BigDecimal value = new BigDecimal(valueOne);
        if (valueUnit.equals(finalUnit)) {
            return value;
        }
        BigDecimal processValue = BigDecimal.ZERO;
        BigDecimal resultValue = BigDecimal.ZERO;
        //1、将valueOne转为ns对应值
        switch (valueUnit) {
            case "d":
                processValue = value.multiply(new BigDecimal("86400000000000"));
                break;
            case "h":
                processValue = value.multiply(new BigDecimal("3600000000000"));
                break;
            case "min":
                processValue = value.multiply(new BigDecimal("60000000000"));
                break;
            case "s":
                processValue = value.multiply(new BigDecimal("1000000000"));
                break;
            case "ms":
                processValue = value.multiply(new BigDecimal("1000000"));
                break;
            case "μs":
                processValue = value.multiply(new BigDecimal("1000"));
                break;
            case "ps":
                processValue = value.multiply(new BigDecimal("0.001"));
                break;
            case "MHz":
                //秒和MHz换算,1MHz=1000000s,1MHz=1000000Hz,1MHz=1000000000000000ns
                processValue = value.multiply(new BigDecimal("1000000000000000"));
                break;
            default:
                processValue = value;
                break;
        }
        //2、将valueOne转为finalUnit对应值
        switch (finalUnit) {
            case "d":
                resultValue = processValue.divide(new BigDecimal("86400000000000"), 12, RoundingMode.HALF_UP);
                break;
            case "h":
                resultValue = processValue.divide(new BigDecimal("3600000000000"), 12, RoundingMode.HALF_UP);
                break;
            case "min":
                resultValue = processValue.divide(new BigDecimal("60000000000"), 12, RoundingMode.HALF_UP);
                break;
            case "s":
                resultValue = processValue.divide(new BigDecimal("1000000000"), 12, RoundingMode.HALF_UP);
                break;
            case "ms":
                resultValue = processValue.divide(new BigDecimal("1000000"), 12, RoundingMode.HALF_UP);
                break;
            case "μs":
                resultValue = processValue.divide(new BigDecimal("1000"), 12, RoundingMode.HALF_UP);
                break;
            case "ps":
                resultValue = processValue.divide(new BigDecimal("0.001"), 12, RoundingMode.HALF_UP);
                break;
            case "MHz":
                //秒和MHz换算,1MHz=1000000s,1MHz=1000000Hz,1MHz=1000000000000000ns
                resultValue = processValue.divide(new BigDecimal("1000000000000000"), 12, RoundingMode.HALF_UP);
                break;
            default:
                resultValue = processValue;
                break;
        }
        return resultValue;
    }

    /**
     * 电压单位换算：kV、V、mV、μV
     * @param valueOne 需要换算的数值
     * @param valueUnit 需要换算的数值单位
     * @param finalUnit 需要换算后的单位
     * @return 换算后的数据
     */
    public static BigDecimal voltageConvert(String valueOne, String valueUnit, String finalUnit) {
        if (StringUtils.isEmpty(valueOne)) {
            return BigDecimal.ZERO;
        }
        BigDecimal value = new BigDecimal(valueOne);
        if (valueUnit.equals(finalUnit)) {
            return value;
        }
        BigDecimal processValue = BigDecimal.ZERO;
        BigDecimal resultValue = BigDecimal.ZERO;
        //1、将valueOne转为 V对应值
        switch (valueUnit) {
            case "kV":
                processValue = value.multiply(new BigDecimal("1000"));
                break;
            case "mV":
                processValue = value.multiply(new BigDecimal("0.001"));
                break;
            case "μV":
                processValue = value.multiply(new BigDecimal("0.000001"));
                break;
            default:
                processValue = value;
                break;
        }
        //2、将valueOne转为finalUnit对应值
        switch (finalUnit) {
            case "kV":
                resultValue = processValue.divide(new BigDecimal("1000"), 4, RoundingMode.HALF_UP);
                break;
            case "mV":
                resultValue = processValue.divide(new BigDecimal("0.001"), 4, RoundingMode.HALF_UP);
                break;
            case "μV":
                resultValue = processValue.divide(new BigDecimal("0.000001"), 4, RoundingMode.HALF_UP);
                break;
            default:
                resultValue = processValue;
                break;
        }
        return resultValue;
    }

    /**
     * 功率单位换算：kW、W、mW、μW
     * @param valueOne 需要换算的数值
     * @param valueUnit 需要换算的数值单位
     * @param finalUnit 需要换算后的单位
     * @return 换算后的数据
     */
    public static BigDecimal powerConvert(String valueOne, String valueUnit, String finalUnit) {
        BigDecimal value = new BigDecimal(valueOne);
        if (valueUnit.equals(finalUnit)) {
            return value;
        }
        BigDecimal processValue = BigDecimal.ZERO;
        BigDecimal resultValue = BigDecimal.ZERO;
        //1、将valueOne转为 V对应值
        switch (valueUnit) {
            case "kW":
                processValue = value.multiply(new BigDecimal("1000"));
                break;
            case "mW":
                processValue = value.multiply(new BigDecimal("0.001"));
                break;
            case "μW":
                processValue = value.multiply(new BigDecimal("0.000001"));
                break;
            default:
                processValue = value;
                break;
        }
        //2、将valueOne转为finalUnit对应值
        switch (finalUnit) {
            case "kW":
                resultValue = processValue.divide(new BigDecimal("1000"), 4, RoundingMode.HALF_UP);
                break;
            case "mW":
                resultValue = processValue.divide(new BigDecimal("0.001"), 4, RoundingMode.HALF_UP);
                break;
            case "μW":
                resultValue = processValue.divide(new BigDecimal("0.000001"), 4, RoundingMode.HALF_UP);
                break;
            default:
                resultValue = processValue;
                break;
        }
        return resultValue;
    }

    /**
     * 电阻单位换算：MΩ、kΩ、Ω、mΩ、μΩ
     * @param valueOne 需要换算的数值
     * @param valueUnit 需要换算的数值单位
     * @param finalUnit 需要换算后的单位
     * @return 换算后的数据
     */
    public static BigDecimal resistanceConvert(String valueOne, String valueUnit, String finalUnit) {
        BigDecimal value = new BigDecimal(valueOne);
        if (valueUnit.equals(finalUnit)) {
            return value;
        }
        BigDecimal processValue = BigDecimal.ZERO;
        BigDecimal resultValue = BigDecimal.ZERO;
        //1、将valueOne转为 Ω对应值
        switch (valueUnit) {
            case "MΩ":
                processValue = value.multiply(new BigDecimal("1000000"));
                break;
            case "kΩ":
                processValue = value.multiply(new BigDecimal("1000"));
                break;
            case "mΩ":
                processValue = value.multiply(new BigDecimal("0.001"));
                break;
            case "μΩ":
                processValue = value.multiply(new BigDecimal("0.000001"));
                break;
            default:
                processValue = value;
                break;
        }
        //2、将valueOne转为finalUnit对应值
        switch (finalUnit) {
            case "MΩ":
                resultValue = processValue.divide(new BigDecimal("1000"), 4, RoundingMode.HALF_UP);
                break;
            case "kΩ":
                resultValue = processValue.divide(new BigDecimal("1000"), 4, RoundingMode.HALF_UP);
                break;
            case "mΩ":
                resultValue = processValue.divide(new BigDecimal("0.001"), 4, RoundingMode.HALF_UP);
                break;
            case "μΩ":
                resultValue = processValue.divide(new BigDecimal("0.000001"), 4, RoundingMode.HALF_UP);
                break;
            default:
                resultValue = processValue;
                break;
        }
        return resultValue;
    }
}