MARKUS

using KCOM.Common;

using Microsoft.Win32;

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Runtime.Serialization.Formatters.Binary;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Ink;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Shapes;

using Telerik.Windows.Controls;

namespace KCOM.Controls

{

    /// <summary>

    /// SignManager.xaml에 대한 상호 작용 논리

    /// </summary>

    public partial class SignManager : UserControl

    {

        public SignManager()

        {

            InitializeComponent();

            this.Loaded += SignManager_Loaded;

        }

        private void SignManager_Loaded(object sender, RoutedEventArgs e)

        {

            var signItem = MarkupToPDF.MarkupContext.GetUserSignItem(App.ViewInfo.UserID);  //await ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseTaskClient.GetSignStrokesAsync(App.ViewInfo.ProjectNO, App.ViewInfo.UserID);

            if (signItem != null)

            {

                StringToStroke(signItem.Strokes);

            }

        }

        private void Reset_Click(object sender, RoutedEventArgs e)

        {

            txtInput.Text = "";

            txtInput.IsEnabled = true;

            SignCanvas.Strokes.Clear();

        }

        private async void Save_Click(object sender, RoutedEventArgs e)

        {

            if (SignCanvas.Strokes.Count > 0)

            {

                var signImage = Convert.ToBase64String(SignatureToBitmapBytes());

                var pointes = SignCanvas.Strokes.Select(x => x.GetBounds());

                var _startX = pointes.Min(x => x.X);

                var _startY = pointes.Min(x => x.Y);

                var _actualWidth = pointes.Max(x => x.Right);

                _actualWidth = Math.Abs(_startX - _actualWidth);

                var _actualHeight = pointes.Max(x => x.Bottom);

                _actualHeight = Math.Abs(_startY - _actualHeight);

                var result = await ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseTaskClient.SetSignDataAsync(

                             App.ViewInfo.UserID, signImage, (int)_startX, (int)_startY, (int)_actualWidth, (int)_actualHeight);

                if (result > 0)

                {

                    var strokesData = Convert.ToBase64String(StrokesToString());

                    var result2 = await ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseTaskClient.SetSignStrokesAsync(

                                 App.ViewInfo.UserID,strokesData);

                    if (result2 > 0)

                    {

                        MarkupToPDF.MarkupContext.SetUserSignItem(App.ViewInfo.UserID, signImage,strokesData);

                        RadWindow.Alert(new DialogParameters()

                        {

                            Content = "Save Signature Completed."

                        });

                    }

                    //var signData = await ViewerDataModel.Instance.SystemMain.dzMainMenu.BaseTaskClient.GetSignDataAsync(App.ViewInfo.ProjectNO, App.ViewInfo.UserID);

                    //SetPreview(signData);

                }

            };

        }

        private void SetPreview(string imgStr)

        {

            byte[] imageBytes = System.Convert.FromBase64String(imgStr);

            BitmapImage returnImage = new BitmapImage();

            using (System.IO.MemoryStream stream = new System.IO.MemoryStream())

            {

                stream.WriteAsync(imageBytes, 0, imageBytes.Length);

                stream.Position = 0;

                System.Drawing.Image img = System.Drawing.Image.FromStream(stream);

                returnImage.BeginInit();

                System.IO.MemoryStream ms = new System.IO.MemoryStream();

                img.Save(ms, System.Drawing.Imaging.ImageFormat.Png);

                ms.Seek(0, System.IO.SeekOrigin.Begin);

                returnImage.StreamSource = ms;

                returnImage.EndInit();

                stream.Close();

            }

        }

        /// <summary>

        /// Sign을 비트맵으로 변환하여 리턴한다.

        /// </summary>

        /// <returns></returns>

        private byte[] SignatureToBitmapBytes()

        {

            RenderTargetBitmap rtb = new RenderTargetBitmap((int)SignCanvas.ActualWidth, (int)SignCanvas.ActualHeight, 96d, 96d, PixelFormats.Default);

            rtb.Render(SignCanvas);

            byte[] bytes = null;

            using (MemoryStream ms = new MemoryStream())

            {

                System.Windows.Media.Imaging.PngBitmapEncoder encoder = new PngBitmapEncoder();

                BitmapFrame frame = BitmapFrame.Create(rtb);

                encoder.Frames.Add(frame);

                encoder.Save(ms);

                ms.Position = 0;

                bytes = new byte[ms.Length];

                ms.Read(bytes, 0, bytes.Length);

            }

            return bytes;

        }

        private byte[] StrokesToString()

        {

            byte[] bytes = null;

            CustomStrokes customStrokes = new CustomStrokes();

            customStrokes.StrokeCollection = new Point[SignCanvas.Strokes.Count][];

            for (int i = 0; i < SignCanvas.Strokes.Count; i++)

            {

                customStrokes.StrokeCollection[i] = new Point[SignCanvas.Strokes[i].StylusPoints.Count];

                for (int j = 0; j < SignCanvas.Strokes[i].StylusPoints.Count; j++)

                {

                    customStrokes.StrokeCollection[i][j] = new Point();

                    customStrokes.StrokeCollection[i][j].X = SignCanvas.Strokes[i].StylusPoints[j].X;

                    customStrokes.StrokeCollection[i][j].Y = SignCanvas.Strokes[i].StylusPoints[j].Y;

                }

            }

            //Serialize

            using (MemoryStream ms = new MemoryStream())

            {

                BinaryFormatter bf = new BinaryFormatter();

                bf.Serialize(ms, customStrokes);

                ms.Position = 0;

                bytes = new byte[ms.Length];

                ms.Read(bytes, 0, bytes.Length);

            }

            return bytes;

        }

        private void StringToStroke(string strokesData)

        {

            try

            {

                //deserialize it

                BinaryFormatter bf = new BinaryFormatter();

                MemoryStream ms = new MemoryStream(Convert.FromBase64String(strokesData));

                CustomStrokes customStrokes = (CustomStrokes)bf.Deserialize(ms);

                //rebuilt it

                for (int i = 0; i < customStrokes.StrokeCollection.Length; i++)

                {

                    if (customStrokes.StrokeCollection[i] != null)

                    {

                        StylusPointCollection stylusCollection = new StylusPointCollection(customStrokes.StrokeCollection[i]);

                        Stroke stroke = new Stroke(stylusCollection);

                        StrokeCollection strokes = new StrokeCollection();

                        strokes.Add(stroke);

                        SignCanvas.Strokes.Add(strokes);

                    }

                }

            }

            catch (Exception ex)

            {

            }

        }

        public StrokeCollection ConvertImageToStrokeCollection(BitmapImage image)

        {  

            // 이미지 크기 조정

            int maxWidth = 900;

            int maxHeight = 200;

            double scaleX = (double)maxWidth / image.PixelWidth;

            double scaleY = (double)maxHeight / image.PixelHeight;

            double scale = Math.Min(scaleX, scaleY);

            TransformedBitmap resizedImage = new TransformedBitmap(image, new ScaleTransform(scale, scale));

            InkCanvas inkCanvas = new InkCanvas();

            inkCanvas.Width = resizedImage.Width;

            inkCanvas.Height = resizedImage.Height;

            // WriteableBitmap 생성

            WriteableBitmap writeableBitmap = new WriteableBitmap(resizedImage);

            // 픽셀 데이터를 저장할 배열 생성

            int stride = writeableBitmap.PixelWidth * (writeableBitmap.Format.BitsPerPixel / 8);

            byte[] pixelData = new byte[writeableBitmap.PixelHeight * stride];

            // 픽셀 데이터 복사

            writeableBitmap.CopyPixels(pixelData, stride, 0);

            progress.Maximum = writeableBitmap.PixelHeight * writeableBitmap.PixelWidth;

            for (int y = 0; y < writeableBitmap.PixelHeight; y++)

            {

                for (int x = 0; x < writeableBitmap.PixelWidth; x++)

                {

                    int index = y * stride + x * (writeableBitmap.Format.BitsPerPixel / 8);

                    byte blue = pixelData[index];

                    byte green = pixelData[index + 1];

                    byte red = pixelData[index + 2];

                    byte alpha = pixelData[index + 3];

                    Color color = Color.FromArgb(alpha, red, green, blue);

                    // 특정 색상(예: 검정색)인 경우에만 Stroke로 변환

                    if (red <= 150 && green <= 150 && blue <= 150 && alpha == 255)

                    {

                        StylusPointCollection points = new StylusPointCollection();

                        points.Add(new StylusPoint(x, y));

                        Stroke stroke = new Stroke(points);

                        inkCanvas.Strokes.Add(stroke);

                        //System.Threading.Thread.SpinWait(10);

                    }

                    // Update progress value

                    progress.Dispatcher.Invoke(() => { 

                        progress.Value = y * writeableBitmap.PixelWidth + x + 1;

                    });

                }

            }

            return inkCanvas.Strokes;

        }

        private string GetSignData()

        {

            string result = "";

            try

            {

            }

            catch (Exception)

            {

                throw;

            }

            return result;

        }

        private void SignCanvas_SourceUpdated(object sender, DataTransferEventArgs e)

        {

            if(SignCanvas.Strokes.Count() > 0)

            {

                txtInput.IsEnabled = false;

            }

            else

            {

                txtInput.IsEnabled = true;

            }

        }

        private void SignCanvas_StrokeCollected(object sender, InkCanvasStrokeCollectedEventArgs e)

        {

            if (SignCanvas.Strokes.Count() > 0)

            {

                txtInput.IsEnabled = false;

            }

            else

            {

                txtInput.IsEnabled = true;

            }

        }

        private void OpenImage_Click(object sender, RoutedEventArgs e)

        {

            OpenFileDialog openFileDialog = new OpenFileDialog();

            openFileDialog.Filter = "Image files (*.jpg, *.jpeg, *.png, *.bmp)|*.jpg;*.jpeg;*.png;*.bmp";

            // 파일 선택 대화 상자 표시

            if (openFileDialog.ShowDialog() == true)

            {

                panelProgress.Dispatcher.Invoke(() => panelProgress.Visibility = Visibility.Visible);

                try

                {

                    // 선택한 파일 경로 가져오기

                    string filePath = openFileDialog.FileName;

                    // BitmapImage 생성 및 파일 로드

                    BitmapImage bitmapImage = new BitmapImage();

                    bitmapImage.BeginInit();

                    bitmapImage.UriSource = new Uri(filePath);

                    bitmapImage.EndInit();

                    var strokes = ConvertImageToStrokeCollection(bitmapImage);

                    SignCanvas.Strokes.Add(strokes);

                }

                catch (Exception)

                {

                    MessageBox.Show("이미지 오류입니다.");

                }

                finally

                {

                    panelProgress.Dispatcher.Invoke(() => panelProgress.Visibility = Visibility.Collapsed);

                }

            }

        }

    }

    [Serializable]

    public sealed class CustomStrokes

    {

        public CustomStrokes() { }

        /// <summary>

        /// The first index is the stroke no.

        /// The second index is for the keep the 2D point.

        /// </summary>

        public Point[][] StrokeCollection;

    }

}