package com.pubtap.android.helpers;

import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.net.Uri;
import android.os.Environment;
import android.os.Parcel;
import android.os.Parcelable;
import android.provider.MediaStore;
import android.text.TextUtils;
import android.util.Pair;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Created by Alexandr Timoshenko on 11/15/13.
 */
public final class PhotoPickerHelper implements Parcelable {
    private Uri mContactPickerUri;

    public Intent getGalleryIntent(Context context){
        Intent galleryintent = new Intent(Intent.ACTION_GET_CONTENT, null);
        galleryintent.setType("image/*");
        return galleryintent;
    }
    public Pair<Intent,Uri> getCameraIntent(Context context,String bucketName) throws IOException {
        Intent cameraIntent = new Intent(
                android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
        cameraIntent.putExtra("android.intent.extras.CAMERA_FACING", 2);
        Uri fileUri = createImageMediaFile(context,bucketName);
        cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, fileUri);
        cameraIntent.putExtra("return-data", false);
        mContactPickerUri = fileUri;
        return new Pair<Intent, Uri>(cameraIntent,fileUri);
    }

    public Uri handleCameraResult(Context context,final Intent data) {
        Uri contactImageUri = mContactPickerUri;
        if (data != null && data.getData() != null) {
            contactImageUri = data.getData();
        } else {
            rotateFileAndReplace(contactImageUri.toString());
        }
        String imageUri = getPath(context, contactImageUri);
        if (TextUtils.isEmpty(imageUri)){
            return resaveImageFromInputStream(context,contactImageUri);
        }
        return Uri.parse(imageUri);
    }
    public static void rotateFileAndReplace(String path) {
        try {
            BitmapFactory.Options optionsChangeSize = new BitmapFactory.Options();
            Bitmap mBitmap = BitmapFactory.decodeFile(path, optionsChangeSize);
            ExifInterface mExif = new ExifInterface(path);
            int orientation = mExif.getAttributeInt(
                    ExifInterface.TAG_ORIENTATION, -1);
            int exifOrientation = 0;
            switch (orientation) {

                case ExifInterface.ORIENTATION_ROTATE_270:
                    exifOrientation = 270;
                    break;

                case ExifInterface.ORIENTATION_ROTATE_180:
                    exifOrientation = 180;
                    break;

                case ExifInterface.ORIENTATION_ROTATE_90:
                    exifOrientation = 90;
                    break;

                case ExifInterface.ORIENTATION_NORMAL:
                    exifOrientation = 0;
                    break;
            }

            if (exifOrientation != 0) {
                mBitmap = rotateAndMirror(mBitmap, exifOrientation, false);
                mBitmap.compress(Bitmap.CompressFormat.PNG, 100, new FileOutputStream(
                        path));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private Uri resaveImageFromInputStream(Context context,Uri contactImageUri){

        InputStream photoStream = null;
        try {
            photoStream  = context.getContentResolver().openInputStream(contactImageUri);
            File tmp = File.createTempFile("phototmp", ".png");
            FileOutputStream fos = new FileOutputStream(tmp);
            int len = 0;
            byte[]buf = new byte[10*1024];
            while ((len=photoStream.read(buf))>0){
                fos.write(buf,0,len);
            }
            photoStream.close();
            fos.close();
            return Uri.fromFile(tmp);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
    public static String getPath(Context ctx, Uri uri) {
        Cursor cursor = null;
        int column_index = 0;
        String path = null;

        try {
            String[] projection = { MediaStore.Images.Media.DATA };
            cursor = ctx.getContentResolver().query(uri, projection, null,
                    null, null);
            column_index = cursor
                    .getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
            cursor.moveToFirst();
            path = cursor.getString(column_index);
        } catch (Exception e){
            e.printStackTrace();
        }
        finally {
            if (cursor != null) {
                cursor.close();
            }
        }
        return path;
    }
    public static Bitmap rotateAndMirror(Bitmap b, int degrees, boolean mirror) {
        if ((degrees != 0 || mirror) && b != null) {
            Matrix m = new Matrix();
            // Mirror first.
            // horizontal flip + rotation = -rotation + horizontal flip
            if (mirror) {
                m.postScale(-1, 1);
                degrees = (degrees + 360) % 360;
                if (degrees == 0 || degrees == 180) {
                    m.postTranslate(b.getWidth(), 0);
                } else if (degrees == 90 || degrees == 270) {
                    m.postTranslate(b.getHeight(), 0);
                } else {
                    throw new IllegalArgumentException("Invalid degrees="
                            + degrees);
                }
            }
            if (degrees != 0) {
                // clockwise
                m.postRotate(degrees, (float) b.getWidth() / 2,
                        (float) b.getHeight() / 2);
            }

            try {
                Bitmap b2 = Bitmap.createBitmap(b, 0, 0, b.getWidth(),
                        b.getHeight(), m, true);
                if (b != b2) {
                    b.recycle();
                    b = b2;
                }
            } catch (OutOfMemoryError ex) {
                ex.printStackTrace();
                // We have no memory to rotate. Return the original bitmap.
            }
        }
        return b;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeParcelable(this.mContactPickerUri, flags);
    }

    public PhotoPickerHelper(Parcel in) {
        this.mContactPickerUri = in.readParcelable(Uri.class.getClassLoader());
    }

    public PhotoPickerHelper() {
    }

    public static Parcelable.Creator<PhotoPickerHelper> CREATOR = new Parcelable.Creator<PhotoPickerHelper>() {
        public PhotoPickerHelper createFromParcel(Parcel source) {
            return new PhotoPickerHelper(source);
        }

        public PhotoPickerHelper[] newArray(int size) {
            return new PhotoPickerHelper[size];
        }
    };

    public static int getOrientation(Context ctx, Uri uri) {
        int orientation = 0;
        Cursor cursor = null;
        try {
            String[] projection = { MediaStore.Images.Media.ORIENTATION };
            cursor = ctx.getContentResolver().query(uri, projection, null,
                    null, null);
            int column_index = cursor
                    .getColumnIndex(MediaStore.Images.Media.ORIENTATION);
            cursor.moveToFirst();
            orientation = cursor.getInt(column_index);
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            if (cursor != null) {
                cursor.close();
            }
        }
        return orientation;
    }

    public Uri getContactPickerUri() {
        return mContactPickerUri;
    }

    public void setContactPickerUri(Uri contactPickerUri) {
        mContactPickerUri = contactPickerUri;
    }

    public static Uri createImageMediaFile(Context context,String bucketName) throws IOException {
        ContentValues values = new ContentValues();
        String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss")
                .format(new Date());
        values.put(MediaStore.Images.Media.TITLE, timeStamp);
        values.put(MediaStore.Images.Media.DISPLAY_NAME, timeStamp);
        values.put(MediaStore.Images.Media.DESCRIPTION, "");
        values.put(MediaStore.Images.Media.DATE_ADDED, System.currentTimeMillis());
        values.put(MediaStore.Images.Media.DATE_TAKEN, System.currentTimeMillis());
        values.put(MediaStore.Images.Media.DATE_MODIFIED, System.currentTimeMillis());
        values.put(MediaStore.Images.Media.MIME_TYPE, "image/png");
        values.put(MediaStore.Images.Media.ORIENTATION, 0);

        File dir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
        dir = new File(dir,bucketName);
        if (!dir.exists()){
            dir.mkdirs();
        }
        File f = new File(dir,"IMG_" + timeStamp + ".png");
        f.createNewFile();

        File parent = f.getParentFile();
        String path = parent.toString().toLowerCase();
        values.put(MediaStore.Images.ImageColumns.BUCKET_ID, path.hashCode());
        values.put(MediaStore.Images.ImageColumns.BUCKET_DISPLAY_NAME, bucketName);
        values.put(MediaStore.Images.Media.DATA, f.getAbsolutePath());
        Uri result = context.getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
        return result;
    }
}