package it.fedeloper.smartcharging.Manager;

import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.drawable.GradientDrawable;
import android.media.ExifInterface;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.Uri;
import android.os.Debug;
import android.provider.MediaStore;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.InetAddress;
import java.net.URI;
import java.net.URL;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import it.fedeloper.smartcharging.R;

/**
 * Created by federico on 11/08/2015.
 */
public class Utils {


    public static String getTipologiaFromId(Context c,int id)
    {
        final String[] tipi = c.getResources().getStringArray(R.array.type_array);
        return tipi[id-1];
    }


    public static Uri getImageUri(Context inContext, Bitmap inImage) {

        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        inImage.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
        String path = MediaStore.Images.Media.insertImage(inContext.getContentResolver(), inImage, "Images", null);
        Uri u=Uri.parse(path);
        String s=getRealPathFromURI(inContext,u);
        File f=new File(s);

        File file= new File(f.getParent(),".nomedia");
        if (!file.exists()){
            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return u;
    }

    public static String getRealPathFromURI(Context context, Uri contentUri) {
        Cursor cursor = null;
        try {
            String[] proj = { MediaStore.Images.Media.DATA };
            cursor = context.getContentResolver().query(contentUri,  proj, null, null, null);
            int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
            cursor.moveToFirst();
            return cursor.getString(column_index);
        } finally {
            if (cursor != null) {
                cursor.close();
            }
        }
    }
    public static int calculateInSampleSize(
            BitmapFactory.Options options, int reqWidth, int reqHeight) {
        // Raw height and width of image
        final int height = options.outHeight;
        final int width = options.outWidth;
        int inSampleSize = 1;

        if (height > reqHeight || width > reqWidth) {

            final int halfHeight = height / 2;
            final int halfWidth = width / 2;

            // Calculate the largest inSampleSize value that is a power of 2 and keeps both
            // height and width larger than the requested height and width.
            while ((halfHeight / inSampleSize) > reqHeight
                    && (halfWidth / inSampleSize) > reqWidth) {
                inSampleSize *= 2;
            }
        }

        return inSampleSize;
    }


    public static int dpToPx(int dp, Context c) {
        DisplayMetrics displayMetrics = c.getResources().getDisplayMetrics();
        int px = Math.round(dp * (displayMetrics.xdpi / DisplayMetrics.DENSITY_DEFAULT));
        return px;
    }

    public static boolean isValidEmailAddress(String email) {
        String ePattern = "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$";
        java.util.regex.Pattern p = java.util.regex.Pattern.compile(ePattern);
        java.util.regex.Matcher m = p.matcher(email);
        return m.matches();
    }

    public static Bitmap getBitmapFromURL(String src) {
        try {
            URL url = new URL(src);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setDoInput(true);
            connection.connect();
            InputStream input = connection.getInputStream();

            return decodeBitmapFromStreamFixed(input, 1000, 1000);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    public static Bitmap decodeBitmapFromStreamFixed(InputStream inputStream, int reqWidth, int reqHeight) {
        return decodeBitmapFromStreamFixed(inputStream, reqWidth, reqHeight, null);
    }

    public static Bitmap decodeBitmapFromStreamFixed(InputStream inputStream, int reqWidth, int reqHeight, String path){
        byte[] byteArr = new byte[0];
        byte[] buffer = new byte[1024];
        int len;
        int count = 0;

        try {
            while ((len = inputStream.read(buffer)) > -1) {
                if (len != 0) {
                    if (count + len > byteArr.length) {
                        byte[] newbuf = new byte[(count + len) * 2];
                        System.arraycopy(byteArr, 0, newbuf, 0, count);
                        byteArr = newbuf;
                    }

                    System.arraycopy(buffer, 0, byteArr, count, len);
                    count += len;
                }
            }

            final BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeByteArray(byteArr, 0, count, options);

            options.inSampleSize = calculateInSampleSize(options, reqWidth,
                    reqHeight);
            options.inPurgeable = true;
            options.inInputShareable = true;
            options.inJustDecodeBounds = false;
            options.inPreferredConfig = Bitmap.Config.ARGB_8888;

            Bitmap finalBitmap = BitmapFactory.decodeByteArray(byteArr, 0, count, options);

            if(path==null)
                return finalBitmap;

            return rotateBitmap(finalBitmap, path);

        } catch (Exception e) {
            e.printStackTrace();

            return null;
        }
    }

    private static Bitmap rotateBitmap(Bitmap finalBitmap, String path) {
        ExifInterface exif = null;
        try {
            exif = new ExifInterface(path);
        } catch (IOException e) {
            e.printStackTrace();
        }
        int orientation;
        try {
        orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_UNDEFINED);
        } catch (NullPointerException e) {
            e.printStackTrace();
            return finalBitmap;
        }

        Matrix matrix = new Matrix();
        switch (orientation) {
            case ExifInterface.ORIENTATION_NORMAL:
                return finalBitmap;
            case ExifInterface.ORIENTATION_FLIP_HORIZONTAL:
                matrix.setScale(-1, 1);
                break;
            case ExifInterface.ORIENTATION_ROTATE_180:
                matrix.setRotate(180);
                break;
            case ExifInterface.ORIENTATION_FLIP_VERTICAL:
                matrix.setRotate(180);
                matrix.postScale(-1, 1);
                break;
            case ExifInterface.ORIENTATION_TRANSPOSE:
                matrix.setRotate(90);
                matrix.postScale(-1, 1);
                break;
            case ExifInterface.ORIENTATION_ROTATE_90:
                matrix.setRotate(90);
                break;
            case ExifInterface.ORIENTATION_TRANSVERSE:
                matrix.setRotate(-90);
                matrix.postScale(-1, 1);
                break;
            case ExifInterface.ORIENTATION_ROTATE_270:
                matrix.setRotate(-90);
                break;
            default:
                return finalBitmap;
        }
        try {
            Bitmap bmRotated =
                    Bitmap.createBitmap(finalBitmap, 0, 0, finalBitmap.getWidth(), finalBitmap.getHeight(), matrix, true);
            finalBitmap.recycle();
            return bmRotated;
        }
        catch (OutOfMemoryError e) {
            e.printStackTrace();
            return null;
        }
    }


    public static Bitmap mergeBitmaps(Bitmap original, Bitmap overlay) {
        Bitmap result = Bitmap.createBitmap(original.getWidth(), original
                .getHeight(), Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(result);
        Paint paint = new Paint();
        paint.setAntiAlias(true);
        if (original.getHeight() < original.getWidth())
            overlay = Utils.getOptimizedBitmap(overlay, original.getHeight());
        else
            overlay = Utils.getOptimizedBitmap(overlay, original.getWidth());

        canvas.drawBitmap(original, 0, 0, paint);
        canvas.drawBitmap(overlay, (original.getWidth() - overlay.getWidth()) / 2, (original.getHeight() - overlay.getHeight()) / 2, paint);

        return result;
    }

    public static Bitmap getOptimizedBitmap(Bitmap b, int maxms) {

        if (b.getWidth() > maxms)
            b = Bitmap.createScaledBitmap(b, b.getWidth() / (b.getWidth() / maxms), b.getHeight() / (b.getWidth() / maxms), false);


        if (b.getHeight() > maxms)
            b = Bitmap.createScaledBitmap(b, b.getWidth() / (b.getHeight() / maxms), b.getHeight() / (b.getHeight() / maxms), false);

        return b;
    }

    public static boolean isConnectionAvailable(Context context) {
        ConnectivityManager connectivityManager
                = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
        return activeNetworkInfo != null && activeNetworkInfo.isConnected();
    }


    public static boolean isNetworkConnected(Context c) {
        ConnectivityManager cm = (ConnectivityManager) c.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo ni = cm.getActiveNetworkInfo();
        if (ni == null)
        {
            toast(c, R.string.no_connection);
            return false;
        }

         else
            return true;
    }
    public boolean isInternetAvailable(Context c) {
        try {
            InetAddress ipAddr = InetAddress.getByName("google.com");

            if (ipAddr.toString().equals(""))
            {
                toast(c, R.string.Internet_no_work);
                return false;
            }

             else
                return true;


        } catch (Exception e) {
            return false;
        }

    }

    public static void toast(Context c,int source) {
        try
        {
            Toast.makeText(c, c.getText(source), Toast.LENGTH_SHORT).show();
        }catch (Exception e){}


//        LayoutInflater inflater = LayoutInflater.from(c);
//        View layout = inflater.inflate(R.layout.toast_layout, null);
//
//        TextView text = (TextView) layout.findViewById(R.id.text);
//        text.setText(c.getString(source));
//
//        Toast toast = new Toast(c.getApplicationContext());
//        toast.setGravity(Gravity.BOTTOM, 0, -100);
//        toast.setDuration(Toast.LENGTH_LONG);
//        toast.setView(layout);
//
//        toast.show();
    }





    }