package com.aoleyun.sn.utils;

import android.content.Context;
import android.content.Intent;

import com.aoleyun.sn.R;
import com.google.gson.JsonObject;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

import static android.os.BatteryManager.BATTERY_HEALTH_COLD;
import static android.os.BatteryManager.BATTERY_HEALTH_DEAD;
import static android.os.BatteryManager.BATTERY_HEALTH_GOOD;
import static android.os.BatteryManager.BATTERY_HEALTH_OVERHEAT;
import static android.os.BatteryManager.BATTERY_HEALTH_OVER_VOLTAGE;
import static android.os.BatteryManager.BATTERY_HEALTH_UNKNOWN;
import static android.os.BatteryManager.BATTERY_HEALTH_UNSPECIFIED_FAILURE;
import static android.os.BatteryManager.BATTERY_PLUGGED_AC;
import static android.os.BatteryManager.BATTERY_PLUGGED_ANY;
import static android.os.BatteryManager.BATTERY_PLUGGED_USB;
import static android.os.BatteryManager.BATTERY_PLUGGED_WIRELESS;
import static android.os.BatteryManager.BATTERY_STATUS_CHARGING;
import static android.os.BatteryManager.BATTERY_STATUS_DISCHARGING;
import static android.os.BatteryManager.BATTERY_STATUS_FULL;
import static android.os.BatteryManager.BATTERY_STATUS_NOT_CHARGING;
import static android.os.BatteryManager.BATTERY_STATUS_UNKNOWN;
import static android.os.BatteryManager.EXTRA_HEALTH;
import static android.os.BatteryManager.EXTRA_LEVEL;
import static android.os.BatteryManager.EXTRA_MAX_CHARGING_CURRENT;
import static android.os.BatteryManager.EXTRA_MAX_CHARGING_VOLTAGE;
import static android.os.BatteryManager.EXTRA_PLUGGED;
import static android.os.BatteryManager.EXTRA_SCALE;
import static android.os.BatteryManager.EXTRA_STATUS;
import static android.os.BatteryManager.EXTRA_TECHNOLOGY;
import static android.os.BatteryManager.EXTRA_TEMPERATURE;
import static android.os.BatteryManager.EXTRA_VOLTAGE;

public class BatteryUtils {

    private static final int DEFAULT_CHARGING_VOLTAGE_MICRO_VOLT = 5000000;

    public static String getBatteryStatus(Context context, Intent intent) {
        int status = intent.getIntExtra(EXTRA_STATUS, BATTERY_STATUS_UNKNOWN);
        int plugged = intent.getIntExtra(EXTRA_PLUGGED, BATTERY_PLUGGED_ANY);
        int level = intent.getIntExtra(EXTRA_LEVEL, 0);
        int scale = intent.getIntExtra(EXTRA_SCALE, 0);
        int health = intent.getIntExtra(EXTRA_HEALTH, BATTERY_HEALTH_UNKNOWN);

        int maxChargingMicroAmp = intent.getIntExtra(EXTRA_MAX_CHARGING_CURRENT, -1);
        int maxChargingMicroVolt = intent.getIntExtra(EXTRA_MAX_CHARGING_VOLTAGE, -1);
        int batteryVolt = intent.getIntExtra(EXTRA_VOLTAGE, -1);
        int temperature = intent.getIntExtra(EXTRA_TEMPERATURE, -1);
        String batteryTechnologyDescript = intent.getStringExtra(EXTRA_TECHNOLOGY);

        final int maxChargingMicroWatt;

        if (maxChargingMicroVolt <= 0) {
            maxChargingMicroVolt = DEFAULT_CHARGING_VOLTAGE_MICRO_VOLT;
        }
        if (maxChargingMicroAmp > 0) {
            // Calculating muW = muA * muV / (10^6 mu^2 / mu); splitting up the divisor
            // to maintain precision equally on both factors.
            maxChargingMicroWatt = (maxChargingMicroAmp / 1000)
                    * (maxChargingMicroVolt / 1000);
        } else {
            maxChargingMicroWatt = -1;
        }

        String statusStr = getStatus(context, status);
        String healthStr = getHealth(context, health);
        String pluggedStr = getPlugged(context, plugged);
        String levelStr = getLevel(level);
        String scaleStr = getLevel(scale);
        String temperatureStr = getTemperature(temperature);
        String batteryVoltStr = getBatteryVolt(batteryVolt);
        String maxChargingMicroAmpStr = getMaxChargingMicroAmp(maxChargingMicroAmp);
        String maxChargingMicroVoltStr = getMaxChargingMicroVolt(maxChargingMicroVolt);

        int currentChargingCurrent = getCurrentChargingCurrent();
        String currentChargingCurrentStr = getCurrentChargingCurrentStr(currentChargingCurrent);
        int currentChargingVoltage = getCurrentChargingVoltage();
        String currentChargingVoltageStr = getCurrentChargingVoltageStr(currentChargingVoltage);


        String result = "\n" + context.getString(R.string.battery_current_level) + levelStr
                + "\n" + context.getString(R.string.battery_current_temperature) + temperatureStr
                + "\n" + context.getString(R.string.battery_current_volt) + batteryVoltStr
                + "\n" + context.getString(R.string.battery_current_charging_current) + currentChargingCurrentStr
                + "\n" + context.getString(R.string.battery_current_charging_voltage) + currentChargingVoltageStr
                + "\n" + context.getString(R.string.battery_status_titls) + statusStr
                + "\n" + context.getString(R.string.battery_plugged_titls) + pluggedStr
                + "\n" + context.getString(R.string.battery_max_charging_current) + maxChargingMicroAmpStr
                + "\n" + context.getString(R.string.battery_max_charging_voltage) + maxChargingMicroVoltStr
                + "\n" + context.getString(R.string.battery_health_titls) + healthStr
                + "\n" + context.getString(R.string.battery_max_level) + scaleStr
                + "\n" + context.getString(R.string.battery_technology_describing) + batteryTechnologyDescript
                + "\n充电速度 = " + maxChargingMicroWatt
                + "\n";
        return result;
    }

    public static JsonObject getBatteryJson(Context context, Intent intent) {
        int status = intent.getIntExtra(EXTRA_STATUS, BATTERY_STATUS_UNKNOWN);
        int plugged = intent.getIntExtra(EXTRA_PLUGGED, BATTERY_PLUGGED_ANY);
        int level = intent.getIntExtra(EXTRA_LEVEL, 0);
        int scale = intent.getIntExtra(EXTRA_SCALE, 0);
        int health = intent.getIntExtra(EXTRA_HEALTH, BATTERY_HEALTH_UNKNOWN);

        int maxChargingMicroAmp = intent.getIntExtra(EXTRA_MAX_CHARGING_CURRENT, -1);
        int maxChargingMicroVolt = intent.getIntExtra(EXTRA_MAX_CHARGING_VOLTAGE, -1);
        int batteryVolt = intent.getIntExtra(EXTRA_VOLTAGE, -1);
        int temperature = intent.getIntExtra(EXTRA_TEMPERATURE, -1);
        String batteryTechnologyDescript = intent.getStringExtra(EXTRA_TECHNOLOGY);

        final int maxChargingMicroWatt;

        if (maxChargingMicroVolt <= 0) {
            maxChargingMicroVolt = DEFAULT_CHARGING_VOLTAGE_MICRO_VOLT;
        }
        if (maxChargingMicroAmp > 0) {
            // Calculating muW = muA * muV / (10^6 mu^2 / mu); splitting up the divisor
            // to maintain precision equally on both factors.
            maxChargingMicroWatt = (maxChargingMicroAmp / 1000)
                    * (maxChargingMicroVolt / 1000);
        } else {
            maxChargingMicroWatt = -1;
        }

        String statusStr = getStatus(context, status);
        String healthStr = getHealth(context, health);
        String pluggedStr = getPlugged(context, plugged);
        String levelStr = getLevel(level);
        String scaleStr = getLevel(scale);
        String temperatureStr = getTemperature(temperature);
        String batteryVoltStr = getBatteryVolt(batteryVolt);
        String maxChargingMicroAmpStr = getMaxChargingMicroAmp(maxChargingMicroAmp);
        String maxChargingMicroVoltStr = getMaxChargingMicroVolt(maxChargingMicroVolt);

        int currentChargingCurrent = getCurrentChargingCurrent();
        String currentChargingCurrentStr = getCurrentChargingCurrentStr(currentChargingCurrent);
        int currentChargingVoltage = getCurrentChargingVoltage();
        String currentChargingVoltageStr = getCurrentChargingVoltageStr(currentChargingVoltage);

        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("battery_quantity", levelStr);
        jsonObject.addProperty("battery_temperature", temperatureStr);
        jsonObject.addProperty("battery_voltage", batteryVoltStr);
        jsonObject.addProperty("charge_current", currentChargingCurrentStr);
        jsonObject.addProperty("charge_voltage", currentChargingVoltageStr);
        jsonObject.addProperty("battery_status", statusStr);
        jsonObject.addProperty("charge_type", pluggedStr);
        jsonObject.addProperty("charge_current_max", maxChargingMicroAmpStr);
        jsonObject.addProperty("charge_voltage_max", maxChargingMicroVoltStr);
        jsonObject.addProperty("battery_health", healthStr);
        jsonObject.addProperty("quantity_max", scaleStr);
        jsonObject.addProperty("battery_desc", batteryTechnologyDescript);
        jsonObject.addProperty("charge_speed", maxChargingMicroWatt);
        return jsonObject;
    }


    private static String getCurrentChargingVoltageStr(int currentChargingVoltage) {
        return String.format("%.3f V", currentChargingVoltage / 1000000.0);
    }

    private static String getCurrentChargingCurrentStr(int currentChargingCurrent) {
        return String.format("%.3f A", currentChargingCurrent / 1000.0);
    }

    /**
     * 当前充电电流 mA
     * <p>
     * adb shell "cat /sys/class/power_supply/battery/BatteryAverageCurrent"
     */
    private static int getCurrentChargingCurrent() {
        int result = 0;
        BufferedReader br = null;
        try {
            String line;
            br = new BufferedReader(new FileReader("/sys/class/power_supply/battery/BatteryAverageCurrent"));
            if ((line = br.readLine()) != null) {
                result = Integer.parseInt(line);
            }

            br.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return result;
    }

    /**
     * 当前充电电压 uV
     * <p>
     * adb shell "cat /sys/class/power_supply/battery/batt_vol"
     */
    private static int getCurrentChargingVoltage() {
        int result = 0;
        BufferedReader br = null;
        try {
            String line;
            br = new BufferedReader(new FileReader("/sys/class/power_supply/battery/batt_vol"));
            if ((line = br.readLine()) != null) {
                result = Integer.parseInt(line);
            }

            br.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return result;
    }

    private static String getMaxChargingMicroVolt(int maxChargingMicroVolt) {
        return String.format("%.1f V", maxChargingMicroVolt / 1000000.0);
    }

    private static String getMaxChargingMicroAmp(int maxChargingMicroAmp) {
        return String.format("%.1f A", maxChargingMicroAmp / 1000000.0);
    }

    private static String getBatteryVolt(int batteryVolt) {
        return String.format("%.3f V", batteryVolt / 1000.0);
    }


    private static String getTemperature(int temperature) {
        return String.format("%.1f ℃", temperature / 10.0);
    }

    private static String getLevel(int level) {
        return String.format("%d %%", level);
    }

    private static String getPlugged(Context context, int plugged) {
        String result = context.getString(R.string.battery_plugged_any);

        switch (plugged) {
            case BATTERY_PLUGGED_ANY:
                break;
            case BATTERY_PLUGGED_AC:
                result = context.getString(R.string.battery_plugged_ac);
                break;
            case BATTERY_PLUGGED_USB:
                result = context.getString(R.string.battery_plugged_usb);
                break;
            case BATTERY_PLUGGED_WIRELESS:
                result = context.getString(R.string.battery_plugged_wireless);
                break;
            default:
        }

        return result;
    }


    private static String getHealth(Context context, int health) {
        String result = context.getString(R.string.battery_health_unknow);

        switch (health) {
            case BATTERY_HEALTH_UNKNOWN:
                break;
            case BATTERY_HEALTH_GOOD:
                result = context.getString(R.string.battery_health_good);
                break;
            case BATTERY_HEALTH_OVERHEAT:
                result = context.getString(R.string.battery_health_overheat);
                break;
            case BATTERY_HEALTH_DEAD:
                result = context.getString(R.string.battery_health_dead);
                break;
            case BATTERY_HEALTH_UNSPECIFIED_FAILURE:
                result = context.getString(R.string.battery_health_unspecified_failure);
                break;
            case BATTERY_HEALTH_OVER_VOLTAGE:
                result = context.getString(R.string.battery_health_over_voltage);
                break;
            case BATTERY_HEALTH_COLD:
                result = context.getString(R.string.battery_health_cold);
                break;
            default:
        }

        return result;
    }


    private static String getStatus(Context context, int status) {
        String result = context.getString(R.string.battery_status_unknown);

        switch (status) {
            case BATTERY_STATUS_FULL:
                result = context.getString(R.string.battery_status_full);
                break;
            case BATTERY_STATUS_NOT_CHARGING:
                result = context.getString(R.string.battery_status_not_charging);
                break;
            case BATTERY_STATUS_DISCHARGING:
                result = context.getString(R.string.battery_status_discharging);
                break;
            case BATTERY_STATUS_CHARGING:
                result = context.getString(R.string.battery_status_charging);
                break;
            case BATTERY_STATUS_UNKNOWN:
                break;
            default:
        }

        return result;
    }
}