package com.app.artesp;

import java.util.List;

import android.annotation.SuppressLint;
import android.content.Context;
import android.hardware.Camera;
import android.hardware.Camera.PictureCallback;
import android.hardware.Camera.Size;
import android.media.MediaRecorder;
import android.os.Build;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;


@SuppressLint({ "NewApi", "ViewConstructor" })
public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {

    private Camera        camera;
    private MediaRecorder recorder;
    private Size          recorderVideoSize;
    private SurfaceHolder surfaceHolder;


    public CameraPreview( Context ctx, Camera camera ) {
        super( ctx );

        debug( "Construtor " );

        this.camera = camera;
        surfaceHolder = getHolder( );
        surfaceHolder.addCallback( this );
        surfaceHolder.setType( SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS );


    }

    /** Metodo  do implements SurfaceHolder.Callback aplicando a previa da camera*/
    public void surfaceCreated(SurfaceHolder holder) {
        debug( "surfaceCreated" );
        try {
            camera.setPreviewDisplay( holder );
            camera.startPreview( );
        }
        catch( Exception e ) {
            e.printStackTrace( );
        }
    }


    /** Inserindo as configuracoes da camera e o PreviewDisplay , finalmente iniciando a camera */
    public void surfaceChanged( SurfaceHolder holder, int format, int width, int height ) {
        debug( "surfaceChanged" );

        if( surfaceHolder.getSurface() == null ) {
            return;
        }

        debug( "surfaceChanged 2" );

        try {
            camera.stopPreview( );
        }
        catch( Exception e ) {
        }

        try {

            Camera.Parameters params = camera.getParameters( );

            List<Size> sizes = null;

            if( Build.VERSION.SDK_INT > Build.VERSION_CODES.HONEYCOMB ) {

                try {
                    sizes = params.getSupportedVideoSizes( );
                }
                catch( Exception e ) {
                }
                if( sizes == null ) {
                    sizes = params.getSupportedPreviewSizes( );
                }
            }
            else {
                sizes = params.getSupportedPreviewSizes( );
            }

            // Definindo as configuracoes da camera
            Size optimalSize = getOptimalPreviewSize( sizes, width, height );
            params.setPreviewSize( optimalSize.width, optimalSize.height );

            recorderVideoSize = optimalSize;

            params.setJpegQuality( 70 );
            params.setFlashMode( Camera.Parameters.FLASH_MODE_AUTO );
            params.setFocusMode( Camera.Parameters.FOCUS_MODE_AUTO );
            params.setSceneMode( Camera.Parameters.SCENE_MODE_AUTO );
            params.set( "cam_mode", 1 );

            //adicionando as configuracoes a camera e adicionando o PreviewDisplay
            camera.setParameters( params );
            camera.setPreviewDisplay( surfaceHolder );

            camera.startPreview( );// Iniciando a camera definitivamente
        }
        catch( Exception e ) {
            e.printStackTrace( );
        }
    }

    /** Para a camera :PreviewDisplay*/
    public void surfaceDestroyed(SurfaceHolder holder) {
        debug( "surfaceDestroyed" );
        if( camera != null ) {
            camera.stopPreview( );
        }
    }

    /** Configuracoes da camera :PreviewDisplay*/
    private Size getOptimalPreviewSize(List<Size> sizes, int w, int h) {
        final double ASPECT_TOLERANCE = 0.05;
        double targetRatio = (double) w / h;
        if (sizes == null) return null;

        Size optimalSize = null;
        double minDiff = Double.MAX_VALUE;

        int targetHeight = h;

        for (Size size : sizes) {
            Log.d( "SIZES", "" + size.width + ", " + size.height );
        }

        // Try to find an size match aspect ratio and size
        for (Size size : sizes) {
            double ratio = (double) size.width / size.height;
            if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) continue;
            if (Math.abs(size.height - targetHeight) < minDiff) {
                optimalSize = size;
                minDiff = Math.abs(size.height - targetHeight);
                break;
            }
        }

        // Cannot find the one match the aspect ratio, ignore the requirement
        if (optimalSize == null) {
            minDiff = Double.MAX_VALUE;
            for (Size size : sizes) {
                if (Math.abs(size.height - targetHeight) < minDiff) {
                    optimalSize = size;
                    minDiff = Math.abs(size.height - targetHeight);
                }
            }
        }
        return optimalSize;
    }

    public boolean startRecording( ) {
        debug( "startRecording" );

        boolean ok = true;

        final int[] audioSources = new int[]{ MediaRecorder.AudioSource.CAMCORDER, MediaRecorder.AudioSource.DEFAULT };
        final int[] audioEncoders = new int[]{ MediaRecorder.AudioEncoder.AAC, MediaRecorder.AudioEncoder.AMR_NB, MediaRecorder.AudioEncoder.DEFAULT };
        final int[] videoCodecs = new int[]{ MediaRecorder.VideoEncoder.MPEG_4_SP, MediaRecorder.VideoEncoder.H264, MediaRecorder.VideoEncoder.H263, MediaRecorder.VideoEncoder.DEFAULT };

        recorder = new MediaRecorder( );
        String fileVideo = CameraUtils.getOutputMediaFile( CameraUtils.MEDIA_TYPE_VIDEO ).toString( );

        for( int sources = 0; sources < audioSources.length; ++sources ) {
            for( int encoders = 0; encoders < audioEncoders.length; ++encoders ) {
                for( int codecs = 0; codecs < videoCodecs.length; ++codecs ) {

                    try {
                        try {
                            camera.unlock( );
                        }
                        catch( Exception e ) {
                            e.printStackTrace( );
                            try {
                                camera.reconnect( );
                                camera.unlock( );
                            }
                            catch( Exception e2 ) {
                                e2.printStackTrace( );
                            }
                        }
                        recorder.reset            ( );
                        recorder.setCamera        ( camera );
                        recorder.setAudioSource   ( audioSources[ sources ] );
                        recorder.setVideoSource   ( MediaRecorder.VideoSource.CAMERA );
                        recorder.setOutputFormat  ( MediaRecorder.OutputFormat.MPEG_4 );
                        recorder.setAudioEncoder  ( audioEncoders[ encoders ] );
                        recorder.setVideoEncoder  ( videoCodecs[ codecs ] );
                        recorder.setPreviewDisplay( getHolder( ).getSurface( ) );
                        recorder.setVideoSize     ( recorderVideoSize.width, recorderVideoSize.height );
                        recorder.setOutputFile    ( fileVideo );
                        recorder.prepare          ( );
                    }
                    catch( Exception e ) {
                        e.printStackTrace( );
                        ok = false;
                    }

                    if( ok == true ) {
                        try {
                            recorder.start( );// inicia a gravacao
                        }
                        catch( Exception e ) {
                            try {
                                recorder.release( );
                                camera.lock( );
                            }
                            catch( Exception e2 ) {
                                e2.printStackTrace();
                            }
                            ok = false;
                            e.printStackTrace( );
                        }
                    }

                    if( ok == true ) {
                        return true;
                    }
                }
            }
        }

        Utils.deleteMediaFileAndThumb( fileVideo );

        return false;
    }


    public void stopRecording( ) {
        debug( "stopRecording" );
        if( recorder != null ) {

            try {
                recorder.release( );
                camera.lock( );
            }
            catch( Exception e ) {
                e.printStackTrace();
            }

            recorder = null;
        }
    }


    public void takeScreenShot( PictureCallback pc ) {
            debug( "takeScreenshot" );
            camera.takePicture( null, null, pc );
        }


    private void debug( String s ) {
        Log.d("CamPreview", s);
    }


    public void onPause( ) {
        if( camera != null ) {
            try {
                camera.stopPreview( );
            }
            catch( Exception e ) {
            }
        }
    }


    public void onResume( ) {
        if( camera != null ) {
            try {
                camera.startPreview( );
            }
            catch( Exception e ) {
            }
        }
    }


    public void release( ) {
        debug( "RELEASE" );
        if( camera != null ) {
            stopRecording( );

            debug( "STOP PREVIEW" );
            try {
                camera.stopPreview( );
            }
            catch( Exception e ) {
            }

            debug( "SET PREVIEW DISPLAY" );
            try {
                camera.setPreviewDisplay( null );
            }
            catch( Exception e ) {
            }

            debug( "CAMERA RELEASE" );
            try {
                camera.release( );
            }
            catch( Exception e ) {
            }
            camera = null;
        }
    }

}