using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using DPUruNet;
using System.Threading;
using System.Drawing.Imaging;

namespace Neo.ActiveX.FingerprintReader
{
	public delegate void PostFingerprintHandler(string fingerprint);

    [GuidAttribute("E11AD111-0F41-4DED-A916-9E7E75C242FD")] 
    [InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIDispatch)]
	public interface ControlEvents
	{
		[DispIdAttribute(0x60020010)]
		void PostFingerprint(string fingerprint);		
	}

    [Guid("34B11111-FFA3-4181-87FC-AF7F65636762")] 
    [ClassInterface(ClassInterfaceType.None), ComSourceInterfaces(typeof(ControlEvents))]
	[ZoneIdentityPermission(SecurityAction.Assert, Zone = System.Security.SecurityZone.Intranet)]
	public partial class FingerprintReaderControl : UserControl //, DPFP.Capture.EventHandler
	{
		public event PostFingerprintHandler PostFingerprint;
		private Reader currentReader;
        public bool InvokeRequired { get; set; }

		public FingerprintReaderControl()
		{
			InitializeComponent();
            currentReader = null;
                      
            if (OpenReader())
            { 
                StartCaptureAsync(this.OnCaptured);
            }
		}

		#region OpenReader
		public bool OpenReader()
		{
            var success = false;
			try
			{
                var readers = ReaderCollection.GetReaders();
                currentReader = readers[0];

                Constants.ResultCode result = Constants.ResultCode.DP_DEVICE_FAILURE;
                result = currentReader.Open(Constants.CapturePriority.DP_PRIORITY_COOPERATIVE);

                if (result != Constants.ResultCode.DP_SUCCESS)
                {
                     SetStatus("Can't open the reader. " + result);
                }
                else
                { 
                    SetStatus("Place your finger on the fingerprint reader to log in...");
                    success = true;
                }
			}
			catch
			{
                SetStatus("Can't open the reader.");				
			}

            return success;
		}
        #endregion

        #region StartCaptureAsync
        public bool StartCaptureAsync(Reader.CaptureCallback OnCaptured)
        {
            // Activate capture handler
            currentReader.On_Captured += new Reader.CaptureCallback(OnCaptured);

            // Call capture
            if (!CaptureFingerAsync())
            {
                return false;
            }

            return true;
        }
        #endregion

        #region GetStatus
		// <summary>
        /// Check the device status before starting capture.
        /// </summary>
        /// <returns></returns>
        public void GetStatus()
        {
            Constants.ResultCode result = currentReader.GetStatus();

            if ((result != Constants.ResultCode.DP_SUCCESS))
            {      
                SetStatus("" + result);
            }

            if ((currentReader.Status.Status == Constants.ReaderStatuses.DP_STATUS_BUSY))
            {
                Thread.Sleep(50);
            }
            else if ((currentReader.Status.Status == Constants.ReaderStatuses.DP_STATUS_NEED_CALIBRATION))
            {
                currentReader.Calibrate();
            }
            else if ((currentReader.Status.Status != Constants.ReaderStatuses.DP_STATUS_READY))
            {
                SetStatus("Reader Status - " + currentReader.Status.Status);
            }
        } 
        #endregion

        #region CaptureFingerAsync
        /// <summary>
        /// Function to capture a finger. Always get status first and calibrate or wait if necessary.  Always check status and capture errors.
        /// </summary>
        /// <param name="fid"></param>
        /// <returns></returns>
        public bool CaptureFingerAsync()
        {
            try
            {
                GetStatus();

                Constants.ResultCode captureResult = currentReader.CaptureAsync(Constants.Formats.Fid.ANSI, Constants.CaptureProcessing.DP_IMG_PROC_DEFAULT, currentReader.Capabilities.Resolutions[0]);
                if (captureResult != Constants.ResultCode.DP_SUCCESS)
                {                  
                    SetStatus("" + captureResult);
                }

                return true;
            }
            catch (Exception ex)
            {
                MessageBox.Show("Error:  " + ex.Message);
                return false;
            }
        }
        #endregion

        #region OnCaptured
        public void OnCaptured(CaptureResult captureResult)
        {
            try
            {
                // Check capture quality and throw an error if bad.
                if (!CheckCaptureResult(captureResult)) return;

                SetStatus("Verifying...");

                // Create bitmap
                foreach (Fid.Fiv fiv in captureResult.Data.Views)
                {
                    var fmd = FeatureExtraction.CreateFmdFromRaw(fiv.RawImage, 1, 0, fiv.Width, fiv.Height, currentReader.Capabilities.Resolutions[0], Constants.Formats.Fmd.DP_VERIFICATION);
                    PostFingerprint(Convert.ToBase64String(fmd.Data.Bytes));
                }
            }
            catch {}
        } 
        #endregion
        
        #region CheckCaptureResult
        /// <summary>
        /// Check quality of the resulting capture.
        /// </summary>
        public bool CheckCaptureResult(CaptureResult captureResult)
        {
            if (captureResult.Data == null || captureResult.ResultCode != Constants.ResultCode.DP_SUCCESS)
            {
                if (captureResult.ResultCode != Constants.ResultCode.DP_SUCCESS)
                {         
                    throw new Exception(captureResult.ResultCode.ToString());
                }

                // Send message if quality shows fake finger
                if ((captureResult.Quality != Constants.CaptureQuality.DP_QUALITY_CANCELED))
                {
                    throw new Exception("Quality - " + captureResult.Quality);
                }
                return false;
            }
            return true;
        }

        #endregion

        #region SetStatus
        protected void SetStatus(string status)
        {
            if (InvokeRequired)
            {
                this.Invoke(new MethodInvoker(delegate
                {
                    StatusLine.Text = status;
                }));                
            }
            else
            {
                StatusLine.Text = status;
            }
        } 
        #endregion

        #region SetPrompt
        protected void SetPrompt(string prompt)
        {
            if (InvokeRequired)
            {
                this.Invoke(new MethodInvoker(delegate
                {
                    Prompt.Text = prompt;
                }));
            }
            else
            {
                Prompt.Text = prompt;
            }           
        } 
        #endregion
       
	}
}