---

// MainWindow.xaml.cs
using Microsoft.Win32;
using System;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media.Animation;
using System.Windows.Media.Imaging;
using System.Windows.Media;

namespace PuzzleApp
{
    public partial class MainWindow : Window
    {
        private BitmapImage? originalImage;
        private const int GridSize = 4;

        private readonly Duration animationDuration =
            new Duration(TimeSpan.FromMilliseconds(200));

        public MainWindow()
        {
            InitializeComponent();
        }

        private void CreatePuzzle(BitmapImage img)
        {
            PuzzleGrid.Children.Clear();

            int tileWidth = img.PixelWidth / GridSize;
            int tileHeight = img.PixelHeight / GridSize;

            for (int y = 0; y < GridSize; y++)
            {
                for (int x = 0; x < GridSize; x++)
                {
                    Int32Rect rect = new Int32Rect(
                        x * tileWidth,
                        y * tileHeight,
                        tileWidth,
                        tileHeight);

                    var cropped = new CroppedBitmap(img, rect);

                    Image piece = new Image
                    {
                        Source = cropped,
                        Tag = (y * GridSize + x).ToString(),
                        Margin = new Thickness(1),
                        Cursor = Cursors.Hand
                    };

                    piece.MouseMove += Img_MouseMove;
                    piece.Drop += Img_Drop;
                    piece.DragEnter += Img_DragEnter;
                    piece.DragLeave += Img_DragLeave;
                    piece.AllowDrop = true;

                    PuzzleGrid.Children.Add(piece);
                }
            }
        }

        private void AnimateSwap(Image img)
        {
            var scale = new DoubleAnimation(1.1, 1.0, animationDuration);

            img.RenderTransform = new ScaleTransform(1.0, 1.0);

            img.RenderTransform.BeginAnimation(
                ScaleTransform.ScaleXProperty, scale);

            img.RenderTransform.BeginAnimation(
                ScaleTransform.ScaleYProperty, scale);
        }

        private void ShuffleBtn_Click(object sender, RoutedEventArgs e)
        {
            if (PuzzleGrid.Children.Count == 0)
            {
                return;
            }

            Random random = new Random();

            var shuffled = PuzzleGrid.Children
                .Cast<Image>()
                .OrderBy(_ => random.Next())
                .ToList();

            PuzzleGrid.Children.Clear();

            foreach (var piece in shuffled)
            {
                PuzzleGrid.Children.Add(piece);
            }
        }

        private void Img_MouseMove(object sender, MouseEventArgs e)
        {
            if (e.LeftButton == MouseButtonState.Pressed &&
                sender is Image img)
            {
                DragDrop.DoDragDrop(img, img, DragDropEffects.Move);
            }
        }

        private void Img_DragEnter(object sender, DragEventArgs e)
        {
            if (sender is Image img)
            {
                img.Opacity = 0.6;
                img.RenderTransform = new ScaleTransform(1.1, 1.1);
            }
        }

        private void Img_DragLeave(object sender, DragEventArgs e)
        {
            if (sender is Image img)
            {
                img.Opacity = 1.0;
                img.RenderTransform = new ScaleTransform(1.0, 1.0);
            }
        }

        private void Img_Drop(object sender, DragEventArgs e)
        {
            if (e.Data.GetData(typeof(Image)) is Image draggedImage &&
                sender is Image targetImage)
            {
                int draggedIndex =
                    PuzzleGrid.Children.IndexOf(draggedImage);

                int targetIndex =
                    PuzzleGrid.Children.IndexOf(targetImage);

                if (draggedIndex == targetIndex)
                {
                    return;
                }

                PuzzleGrid.Children.RemoveAt(
                    Math.Max(draggedIndex, targetIndex));

                PuzzleGrid.Children.RemoveAt(
                    Math.Min(draggedIndex, targetIndex));

                if (draggedIndex < targetIndex)
                {
                    PuzzleGrid.Children.Insert(
                        draggedIndex, targetImage);

                    PuzzleGrid.Children.Insert(
                        targetIndex, draggedImage);
                }
                else
                {
                    PuzzleGrid.Children.Insert(
                        targetIndex, draggedImage);

                    PuzzleGrid.Children.Insert(
                        draggedIndex, targetImage);
                }

                AnimateSwap(draggedImage);
                AnimateSwap(targetImage);

                targetImage.Opacity = 1.0;
                targetImage.RenderTransform =
                    new ScaleTransform(1.0, 1.0);
            }
        }

        private void LoadBtn_Click(object sender, RoutedEventArgs e)
        {
            var dlg = new OpenFileDialog
            {
                Filter = "Images|*.png;*.bmp;*.jpg;*.jpeg|All files|*.*"
            };

            if (dlg.ShowDialog() == true)
            {
                originalImage =
                    new BitmapImage(new Uri(dlg.FileName));

                CreatePuzzle(originalImage);
            }
        }
    }
}