package org.renpy.android;

import android.content.Context;
import android.os.Vibrator;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.util.DisplayMetrics;
import android.view.inputmethod.InputMethodManager;
import android.view.inputmethod.EditorInfo;
import android.view.View;

import java.util.List;
import java.util.ArrayList;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiManager;
import android.content.BroadcastReceiver;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;


/**
 * Methods that are expected to be called via JNI, to access the
 * device's non-screen hardware. (For example, the vibration and
 * accelerometer.)
 */
public class Hardware {

    // The context.
    static Context context;
    static View view;

    /**
     * Vibrate for s seconds.
     */
    public static void vibrate(double s) {
        Vibrator v = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
        if (v != null) {
            v.vibrate((int) (1000 * s));
        }
    }

    /**
     * Get an Overview of all Hardware Sensors of an Android Device
     */
    public static String getHardwareSensors() {
        SensorManager sm = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
        List<Sensor> allSensors = sm.getSensorList(Sensor.TYPE_ALL);

        if (allSensors != null) {
            String resultString = "";
            for (Sensor s : allSensors) {
                resultString += String.format("Name=" + s.getName());
                resultString += String.format(",Vendor=" + s.getVendor());
                resultString += String.format(",Version=" + s.getVersion());
                resultString += String.format(",MaximumRange=" + s.getMaximumRange());
                // XXX MinDelay is not in the 2.2
                //resultString += String.format(",MinDelay=" + s.getMinDelay());
                resultString += String.format(",Power=" + s.getPower());
                resultString += String.format(",Type=" + s.getType() + "\n");
            }
            return resultString;
        }
        return "";
    }


    /**
     * Get Access to 3 Axis Hardware Sensors Accelerometer, Orientation and Magnetic Field Sensors
     */
    public static class generic3AxisSensor implements SensorEventListener {
        private final SensorManager sSensorManager;
        private final Sensor sSensor;
        private final int sSensorType;
        SensorEvent sSensorEvent;

        public generic3AxisSensor(int sensorType) {
            sSensorType = sensorType;
            sSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
            sSensor = sSensorManager.getDefaultSensor(sSensorType);
        }

        public void onAccuracyChanged(Sensor sensor, int accuracy) {
        }

        public void onSensorChanged(SensorEvent event) {
            sSensorEvent = event;
        }

        /**
         * Enable or disable the Sensor by registering/unregistering
         */
        public void changeStatus(boolean enable) {
            if (enable) {
                sSensorManager.registerListener(this, sSensor, SensorManager.SENSOR_DELAY_NORMAL);
            } else {
                sSensorManager.unregisterListener(this, sSensor);
            }
        }

        /**
         * Read the Sensor
         */ 
        public float[] readSensor() {
            if (sSensorEvent != null) {
                return sSensorEvent.values;
            } else {
                float rv[] = { 0f, 0f, 0f };
                return rv;
            }
        }
    }

    public static generic3AxisSensor accelerometerSensor = null;
    public static generic3AxisSensor orientationSensor = null;
    public static generic3AxisSensor magneticFieldSensor = null;

    /**
     * functions for backward compatibility reasons
     */

    public static void accelerometerEnable(boolean enable) {
        if ( accelerometerSensor == null )
            accelerometerSensor = new generic3AxisSensor(Sensor.TYPE_ACCELEROMETER);
        accelerometerSensor.changeStatus(enable);
    }
    public static float[] accelerometerReading() {
        float rv[] = { 0f, 0f, 0f };
        if ( accelerometerSensor == null )
            return rv;
        return (float[]) accelerometerSensor.readSensor();
    }
    public static void orientationSensorEnable(boolean enable) {
        if ( orientationSensor == null )
            orientationSensor = new generic3AxisSensor(Sensor.TYPE_ORIENTATION);
        orientationSensor.changeStatus(enable);
    }
    public static float[] orientationSensorReading() {
        float rv[] = { 0f, 0f, 0f };
        if ( orientationSensor == null )
            return rv;
        return (float[]) orientationSensor.readSensor();
    }
    public static void magneticFieldSensorEnable(boolean enable) {
        if ( magneticFieldSensor == null )
            magneticFieldSensor = new generic3AxisSensor(Sensor.TYPE_MAGNETIC_FIELD);
        magneticFieldSensor.changeStatus(enable);
    }
    public static float[] magneticFieldSensorReading() {
        float rv[] = { 0f, 0f, 0f };
        if ( magneticFieldSensor == null )
            return rv;
        return (float[]) magneticFieldSensor.readSensor();
    }

    static public DisplayMetrics metrics = new DisplayMetrics();

    /**
     * Get display DPI.
     */
    public static int getDPI() {
        return metrics.densityDpi;
    }

    /**
     * Show the soft keyboard.
     */
    public static void showKeyboard(int input_type) {
        //Log.i("python", "hardware.Java show_keyword  " input_type);

        InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);

        SDLSurfaceView vw = (SDLSurfaceView) view;

        int inputType = input_type;

        if (vw.inputType != inputType){
            vw.inputType = inputType;
            imm.restartInput(view);
            }

        imm.showSoftInput(view, InputMethodManager.SHOW_FORCED);
    }

    /**
     * Hide the soft keyboard.
     */
    public static void hideKeyboard() {
        InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }

    /**
     * Scan WiFi networks
     */
    static List<ScanResult> latestResult;

    public static void enableWifiScanner()
    {
        IntentFilter i = new IntentFilter();
        i.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);

        context.registerReceiver(new BroadcastReceiver() {

            @Override
            public void onReceive(Context c, Intent i) {
                // Code to execute when SCAN_RESULTS_AVAILABLE_ACTION event occurs
                WifiManager w = (WifiManager) c.getSystemService(Context.WIFI_SERVICE);
                latestResult = w.getScanResults(); // Returns a <list> of scanResults
            }

        }, i);

    }

    public static String scanWifi() {

        // Now you can call this and it should execute the broadcastReceiver's
        // onReceive()
        WifiManager wm = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        boolean a = wm.startScan();

        if (latestResult != null){

            String latestResultString = "";
            for (ScanResult result : latestResult)
            {
                latestResultString += String.format("%s\t%s\t%d\n", result.SSID, result.BSSID, result.level);
            }

            return latestResultString;
        }

        return "";
    }

    /**
     * network state
     */

    public static boolean network_state = false;

    /**
     * Check network state directly
     *
     * (only one connection can be active at a given moment, detects all network type)
     *
     */
    public static boolean checkNetwork()
    {
        boolean state = false;
        final ConnectivityManager conMgr =  (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);

        final NetworkInfo activeNetwork = conMgr.getActiveNetworkInfo();
        if (activeNetwork != null && activeNetwork.isConnected()) {
            state = true;
        } else {
            state = false;
        }

        return state;
    }

    /**
     * To recieve network state changes
     */
    public static void registerNetworkCheck()
    {
        IntentFilter i = new IntentFilter();
        i.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
        context.registerReceiver(new BroadcastReceiver() {

            @Override
            public void onReceive(Context c, Intent i) {
                network_state = checkNetwork();
            }

        }, i);
    }

}