import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.hardware.Camera;
import android.hardware.Camera.CameraInfo;
import android.media.CamcorderProfile;
import android.media.MediaMetadataRetriever;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.os.Environment;
import android.os.SystemClock;
import android.util.Base64;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Chronometer;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.Toast;
import com.itw.toshalsg.util.CameraPreview;
import com.itw.toshalsg.util.CommonUtils;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;

public class VideoRecorderActivity extends Activity implements OnClickListener {

    private static final String TAG = "VideoRecorderActivity";

    FrameLayout preview;

    private Camera mCamera;
    private CameraPreview mPreview;
    private MediaRecorder mMediaRecorder;
    private boolean isRecording = false;
    private boolean iscamera_swap = false;

    Chronometer timer_view;

    Button captureButton;
    ImageView imag_camera_swap;
    private int cameraId = 0;
    String video_Path, video_duration, video_thum_image;

	/*@Override
     protected void onStart()
	 {
	 	super.onStart();
	 	FlurryAgent.onStartSession(this, getResources().getString(R.string.flurry_key));
	 }

	 @Override
	 protected void onStop()
	 {
	 	super.onStop();
	 	FlurryAgent.onEndSession(this);
	 }*/

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.video_recorder);

        if (!getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)) {
            Toast.makeText(this, "This phone has no camera!", Toast.LENGTH_SHORT).show();
            finish();
        }

        captureButton = (Button) findViewById(R.id.button_capture);
        imag_camera_swap = (ImageView) findViewById(R.id.imag_camera_swap);
        captureButton.setOnClickListener(this);
        imag_camera_swap.setOnClickListener(this);

        video_Path = getExternalDirectoryPath()+"Toshal_Video"+ CommonUtils.getCurrentTimeStamp()+".mp4";
    }

    private int findFrontFacingCamera() {
        int cameraId = -1;
        // Search for the front facing camera
        int numberOfCameras = Camera.getNumberOfCameras();
        for (int i = 0; i < numberOfCameras; i++) {
            CameraInfo info = new CameraInfo();
            Camera.getCameraInfo(i, info);
            if (info.facing == CameraInfo.CAMERA_FACING_FRONT) {
                Log.d("findFrontFacingCamera", "Camera found");
                cameraId = i;
                break;
            }
        }
        return cameraId;
    }

    @Override
    protected void onResume() {
        super.onResume();

        try {

            mCamera = Camera.open();
            mCamera.setDisplayOrientation(90);
            // Create our Preview view and set it as the content of our activity.
            mPreview = new CameraPreview(this, mCamera);

            preview = (FrameLayout) findViewById(R.id.camera_preview);
            preview.addView(mPreview);

            RelativeLayout relaytive_bottom = (RelativeLayout) findViewById(R.id.relaytive_bottom);

            timer_view = (Chronometer) findViewById(R.id.timer_view);
            captureButton.setText("Start");

            relaytive_bottom.bringToFront();
        } catch (Exception e) {
            Log.e("err on resume", "camera load");
            e.printStackTrace();
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        releaseMediaRecorder();       // if you are using MediaRecorder, release it first
        releaseCamera();              // release the camera immediately on pause event
    }

    private void releaseMediaRecorder() {
        if (mMediaRecorder != null) {
            mMediaRecorder.reset();   // clear recorder configuration
            mMediaRecorder.release(); // release the recorder object
            mMediaRecorder = null;
            mCamera.lock();           // lock camera for later use
        }
    }

    private void releaseCamera() {
        if (mCamera != null) {
            mCamera.release();        // release the camera for other applications
            mCamera = null;
        }
    }

    private boolean prepareVideoRecorder() {

        //		StrictMode.ThreadPolicy old = StrictMode.getThreadPolicy();
        //		StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder().permitDiskWrites().permitDiskReads().permitCustomSlowCalls().build());

        mMediaRecorder = new MediaRecorder();
        /*try {
		    mCamera.setPreviewDisplay(null);
		} catch (IOException ioe) {
		    Log.d(TAG, "IOException nullifying preview display: " + ioe.getMessage());
		}*/
        // Step 1: Unlock and set camera to MediaRecorder

        mCamera.unlock();
        mMediaRecorder.setCamera(mCamera);
        //mMediaRecorder.setOrientationHint(180);
        // Step 2: Set sources
        mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.DEFAULT);
        mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.DEFAULT);

        // Step 3: Set a CamcorderProfile (requires API Level 8 or higher)
        if (CamcorderProfile.hasProfile(cameraId, CamcorderProfile.QUALITY_480P)) {
            mMediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_480P));
            Log.i("quality_480p", "QUALITY_480p");
        } else if (CamcorderProfile.hasProfile(cameraId, CamcorderProfile.QUALITY_QVGA)) {
            mMediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_QVGA));
            Log.i("quality_qvga", "QVGA");
        }

        mMediaRecorder.setVideoEncodingBitRate(690000);
        // Step 4: Set output file
        // mMediaRecorder.setOutputFile(MediaUtil.getOutputMediaFile(MediaUtil.MEDIA_TYPE_VIDEO).toString());
        mMediaRecorder.setOutputFile(video_Path);
        // Step 5: Set the preview output
        mMediaRecorder.setPreviewDisplay(mPreview.getHolder().getSurface());

        // Step 6: Prepare configured MediaRecorder
        try {

            mMediaRecorder.prepare();
            //			StrictMode.setThreadPolicy(old);
        } catch (IllegalStateException e) {
            Log.e(TAG, "IllegalStateException preparing MediaRecorder: " + e.getMessage());
            e.printStackTrace();
            //			releaseMediaRecorder();
            return false;
        } catch (IOException e) {
            Log.e(TAG, "IOException preparing MediaRecorder: " + e.getMessage());
            e.printStackTrace();
            //			releaseMediaRecorder();
            return false;
        } catch (Exception e) {
            Log.e("cam prepare err", "" + e);
            e.printStackTrace();
            return false;
        }
        return true;
    }

    @SuppressWarnings("deprecation")
    @Override
    public void onClick(final View v) {

        try {

            if (v == imag_camera_swap) {
                mCamera.stopPreview();
                mCamera.release();
                //releaseMediaRecorder();
                if (iscamera_swap) {
                    mCamera = Camera.open();
                    iscamera_swap = false;
                } else {
                    cameraId = findFrontFacingCamera();
                    Log.d("cameraId", cameraId + "==");
                    if (cameraId < 0) {
                        Toast.makeText(this, "No front facing camera found.", Toast.LENGTH_LONG).show();
                        mCamera = Camera.open();
                        iscamera_swap = true;
                    } else {
                        mCamera = Camera.open(cameraId);
                        // mCamera.startPreview();
                        iscamera_swap = true;
                    }
                }

                try {
                    mCamera.setPreviewDisplay(mPreview.getHolder());
                    mCamera.setDisplayOrientation(90);
                    mCamera.startPreview();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        } catch (Exception e) {
            Log.e("cam swap err", "" + e);
            e.printStackTrace();
        }
        if (v == captureButton) {

            if (isRecording) {
                // stop recording and release camera
                //releaseCamera();

                AlertDialog alertDialog = new AlertDialog.Builder(this).create();

                alertDialog.setTitle("Alert");
                alertDialog.setMessage("Are you sure you want to stop Recording?");
                //				alertDialog.setIcon(R.drawable.tick);
                alertDialog.setButton("OK", new DialogInterface.OnClickListener() {

                    public void onClick(DialogInterface dialog, int which) {
                        Boolean is_recorded = false;
                        try {
                            mMediaRecorder.stop();  // stop the recording
                            is_recorded = true;
                        } catch (Exception e) {
                            Log.e("mMediaRecorder Stop", e + "");
                            e.printStackTrace();
                            File mfile = new File(video_Path);
                            mfile.delete();
                            is_recorded = false;
                        }

                        timer_view.stop();
                        releaseMediaRecorder(); // release the MediaRecorder object
                        mCamera.lock();         // take camera access back from MediaRecorder

                        // inform the user that recording has stopped
                        Button b = (Button) v;
                        b.setText("Start");
                        isRecording = false;

                        if (is_recorded) { handleCameraVideo(); }
                    }
                });

                alertDialog.setButton2("Cancel", new DialogInterface.OnClickListener() {

                    public void onClick(DialogInterface dialog, int which) {
                        dialog.dismiss();
                    }
                });
                alertDialog.show();
            } else {
                Log.i("else", "hi");
                if (prepareVideoRecorder()) {
                    // Camera is available and unlocked, MediaRecorder is prepared,
                    // now you can start recording
                    try {
                        Log.i("else if", "hi");
                        mMediaRecorder.start();
                        timer_view.setBase(SystemClock.elapsedRealtime());
                        timer_view.start();
                        // inform the user that recording has started
                        Button b = (Button) v;
                        b.setText("Stop");

                        isRecording = true;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                } else {
                    // prepare didn't work, release the camera
                    releaseMediaRecorder();
                    // inform user
                }
            }
        }
    }

    private void handleCameraVideo() {
        Log.i("recorging screen selectedPath:", video_Path + "==");

        MediaMetadataRetriever retriever = new MediaMetadataRetriever();
        try {
            retriever.setDataSource(video_Path);
            Bitmap bitmap = retriever.getFrameAtTime(0, MediaMetadataRetriever.OPTION_CLOSEST);

            Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, bitmap.getWidth(), bitmap.getHeight(), true);

            // create a matrix object
            Matrix matrix = new Matrix();
            matrix.postRotate(90); // anti-clockwise by 90 degrees//ANT TIME DERREGEE CHANGE HERE

            // create a new bitmap from the original using the matrix to transform the result
            Bitmap rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true);

            //Bitmap image_bitmap = getResizedBitmap(rotatedBitmap,200,320);

            ByteArrayOutputStream mByteArrayOutputStream = new ByteArrayOutputStream();
            rotatedBitmap.compress(Bitmap.CompressFormat.JPEG, 75, mByteArrayOutputStream);
            byte[] mbyte_array = mByteArrayOutputStream.toByteArray();
            video_thum_image = Base64.encodeToString(mbyte_array, Base64.DEFAULT);

            Log.i("base 64", video_thum_image);

			/* ExifInterface exif = new ExifInterface(send_video_image);
   	  	int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1);

   	  Log.i("orientation", orientation+"===");*/

        } catch (IllegalArgumentException ex) {
            ex.printStackTrace();
        } catch (RuntimeException es) {
            es.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        video_duration = timer_view.getText().toString();
        //Log.i("video_duration", video_duration);

        Intent data = new Intent();
        data.putExtra("video_duration", video_duration);
        if (video_thum_image != null) {
            data.putExtra("video_thum_image", video_thum_image);
        } else {

            try {
                Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.plain_image);
                Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, bitmap.getWidth(), bitmap.getHeight(), true);

                // create a matrix object
                Matrix matrix = new Matrix();
                matrix.postRotate(90); // anti-clockwise by 90 degrees//ANT TIME DERREGEE CHANGE HERE

                // create a new bitmap from the original using the matrix to transform the result
                Bitmap rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0, scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix, true);

                //Bitmap image_bitmap = getResizedBitmap(rotatedBitmap,200,320);

                ByteArrayOutputStream mByteArrayOutputStream = new ByteArrayOutputStream();
                rotatedBitmap.compress(Bitmap.CompressFormat.JPEG, 75, mByteArrayOutputStream);
                byte[] mbyte_array = mByteArrayOutputStream.toByteArray();
                video_thum_image = Base64.encodeToString(mbyte_array, Base64.DEFAULT);

                Log.i("base 64", video_thum_image);

                data.putExtra("video_thum_image", video_thum_image);
            } catch (IllegalArgumentException ex) {
                ex.printStackTrace();
            } catch (RuntimeException es) {
                es.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        data.putExtra("video_Path", video_Path);
        setResult(RESULT_OK, data);
        finish();
    }

    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        releaseCamera();
        releaseMediaRecorder();
    }

    private String getExternalDirectoryPath(){
        String mainDirectoryPath = Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "FolderName" + File.separator;
        File mainDirectoryPathFile = new File(mainDirectoryPath);
        Log.i("external file path", mainDirectoryPathFile.getAbsolutePath());

        if (!mainDirectoryPathFile.exists()) {
            mainDirectoryPathFile.mkdirs();
        }

        String mainFolderPath = mainDirectoryPathFile.getAbsolutePath() + File.separator + "FolderName" + File.separator;
        File mainFolderPathFile = new File(mainFolderPath);
        Log.i("external folder path", mainFolderPathFile.getAbsolutePath());

        if (!mainFolderPathFile.exists()) {
            mainFolderPathFile.mkdirs();
        }
        return  mainFolderPathFile.getAbsolutePath() + File.separator;
    }

    public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {
	private static final String TAG = "CameraPreview";

    private SurfaceHolder mHolder;
    private Camera mCamera;

    public CameraPreview(Context context, Camera camera) {
        super(context);
        mCamera = camera;

        // Install a SurfaceHolder.Callback so we get notified when the
        // underlying surface is created and destroyed.
        mHolder = getHolder();
        mHolder.addCallback(this);
        // deprecated setting, but required on Android versions prior to 3.0
        mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    }

    public void surfaceCreated(SurfaceHolder holder) {
        // The Surface has been created, now tell the camera where to draw the preview.
        try {
            mCamera.setPreviewDisplay(holder);
            mCamera.startPreview();
        } catch (IOException e) {
            Log.d(TAG, "Error setting camera preview: " + e.getMessage());
        }
    }

    public void surfaceDestroyed(SurfaceHolder holder) {
        // empty. Take care of releasing the Camera preview in your activity.
    }

    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
        // If your preview can change or rotate, take care of those events here.
        // Make sure to stop the preview before resizing or reformatting it.

        if (mHolder.getSurface() == null){
          // preview surface does not exist
          return;
        }

        // stop preview before making changes
        try {
            mCamera.stopPreview();
        } catch (Exception e){
          // ignore: tried to stop a non-existent preview
        }

        // set preview size and make any resize, rotate or
        // reformatting changes here

        // start preview with new settings
        try {
            mCamera.setPreviewDisplay(mHolder);
            mCamera.startPreview();

        } catch (Exception e){
            Log.d(TAG, "Error starting camera preview: " + e.getMessage());
        }
    }
}
}