static class DialogHelper
{
  internal static int ShowWindow(Window window, IntPtr ownerHandle)
  {
    var helper = new WindowInteropHelper(window) {Owner = ownerHandle};
    if (window.WindowStartupLocation == WindowStartupLocation.CenterOwner)
      window.SourceInitialized += delegate
      {
        if (!NativeMethods.GetWindowRect(ownerHandle, out var lpRect)) return;
        var target = HwndSource.FromHwnd(helper.Handle)?.CompositionTarget;
        if (target == null) return;
        var point = target.TransformToDevice.Transform(new Point(window.ActualWidth, window.ActualHeight));
        var rECT = NativeMethods.CenterRectOnSingleMonitor(lpRect, (int)point.X, (int)point.Y);
        var point2 = target.TransformFromDevice.Transform(new Point(rECT.Left, rECT.Top));
        window.WindowStartupLocation = WindowStartupLocation.Manual;
        window.Left = point2.X;
        window.Top = point2.Y;
      };
    var flag = window.ShowDialog();
    return flag.HasValue ? (flag.Value ? 1 : 2) : 0;
  }
}

static class NativeMethods
{
  public struct RECT
  {
    public int Left;

    public int Top;

    public int Right;

    public int Bottom;

    public Point Position => new Point(Left, Top);

    public Size Size => new Size(Width, Height);

    public int Height
    {
      get => Bottom - Top;
      set => Bottom = Top + value;
    }

    public int Width
    {
      get => Right - Left;
      set => Right = Left + value;
    }

    public RECT(int left, int top, int right, int bottom)
    {
      Left = left;
      Top = top;
      Right = right;
      Bottom = bottom;
    }

    public RECT(Rectangle r)
    {
      Left = r.Left;
      Top = r.Top;
      Right = r.Right;
      Bottom = r.Bottom;
    }

    public RECT(Rect rect)
    {
      Left = (int)rect.Left;
      Top = (int)rect.Top;
      Right = (int)rect.Right;
      Bottom = (int)rect.Bottom;
    }

    public void Offset(int dx, int dy)
    {
      Left += dx;
      Right += dx;
      Top += dy;
      Bottom += dy;
    }
  }
  public struct MONITORINFO
  {
    public uint cbSize;

    public RECT rcMonitor;

    public RECT rcWork;

    public uint dwFlags;
  }

  static void FindMaximumSingleMonitorRectangle(RECT windowRect, out RECT screenSubRect, out RECT monitorRect)
  {
    var rects = new List<RECT>();
    EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, delegate(IntPtr hMonitor, IntPtr hdcMonitor, ref RECT rect, IntPtr lpData)
    {
      var monitorInfo = default(MONITORINFO);
      monitorInfo.cbSize = (uint)Marshal.SizeOf(typeof(MONITORINFO));
      GetMonitorInfo(hMonitor, ref monitorInfo);
      rects.Add(monitorInfo.rcWork);
      return true;
    }, IntPtr.Zero);
    var num = 0L;
    var rECT = new RECT
    {
      Left = 0,
      Right = 0,
      Top = 0,
      Bottom = 0
    };
    screenSubRect = rECT;
    rECT = new RECT
    {
      Left = 0,
      Right = 0,
      Top = 0,
      Bottom = 0
    };
    monitorRect = rECT;
    foreach (var item in rects)
    {
      var lprcSrc = item;
      IntersectRect(out var lprcDst, ref lprcSrc, ref windowRect);
      long num2 = lprcDst.Width * lprcDst.Height;
      if (num2 > num)
      {
        screenSubRect = lprcDst;
        monitorRect = item;
        num = num2;
      }
    }
  }
  static RECT CenterInRect(RECT parentRect, int childWidth, int childHeight, RECT monitorClippingRect)
  {
    var result = default(RECT);
    result.Left = parentRect.Left + (parentRect.Width - childWidth) / 2;
    result.Top = parentRect.Top + (parentRect.Height - childHeight) / 2;
    result.Width = childWidth;
    result.Height = childHeight;
    result.Left = Math.Min(result.Right, monitorClippingRect.Right) - result.Width;
    result.Top = Math.Min(result.Bottom, monitorClippingRect.Bottom) - result.Height;
    result.Left = Math.Max(result.Left, monitorClippingRect.Left);
    result.Top = Math.Max(result.Top, monitorClippingRect.Top);
    return result;
  }
  public static RECT CenterRectOnSingleMonitor(RECT parentRect, int childWidth, int childHeight)
  {
    FindMaximumSingleMonitorRectangle(parentRect, out var screenSubRect, out var monitorRect);
    return CenterInRect(screenSubRect, childWidth, childHeight, monitorRect);
  }
  [return: MarshalAs(UnmanagedType.Bool)]
  internal delegate bool EnumMonitorsDelegate(IntPtr hMonitor, IntPtr hdcMonitor, ref RECT lprcMonitor, IntPtr dwData);

  [DllImport("user32.dll")]
  [return: MarshalAs(UnmanagedType.Bool)]
  internal static extern bool EnumDisplayMonitors(IntPtr hdc, IntPtr lprcClip, EnumMonitorsDelegate lpfnEnum, IntPtr dwData);

  [DllImport("user32.dll")]
  [return: MarshalAs(UnmanagedType.Bool)]
  internal static extern bool GetMonitorInfo(IntPtr hMonitor, ref MONITORINFO monitorInfo);

  [DllImport("user32.dll")]
  [return: MarshalAs(UnmanagedType.Bool)]
  internal static extern bool IntersectRect(out RECT lprcDst, [In] ref RECT lprcSrc1, [In] ref RECT lprcSrc2);
  
  [DllImport("user32.dll")]
  [return: MarshalAs(UnmanagedType.Bool)]
  public static extern bool GetWindowRect(IntPtr hwnd, out RECT lpRect);
}