using OpenCvSharp;
using Com.Lmc.ShuiYin.One.Util;

namespace Com.Lmc.ShuiYin.One.Converter
{
    public class DctConverter : Converter
    {
        public Mat Start(Mat src)
        {
            if ((src.Cols & 1) != 0)
            {
                Cv2.CopyMakeBorder(src, src, 0, 0, 0, 1, BorderTypes.Constant, Scalar.All(0));
            }
            if ((src.Rows & 1) != 0)
            {
                Cv2.CopyMakeBorder(src, src, 0, 1, 0, 0, BorderTypes.Constant, Scalar.All(0));
            }
            src.ConvertTo(src, MatType.CV_32F);
            Cv2.Dct(src, src);
            return src;
        }

        public void Inverse(Mat com)
        {
            Cv2.Idct(com, com);
        }

        public void AddTextWatermark(Mat com, string watermark)
        {
            Cv2.PutText(com, watermark,
                new Point(com.Cols >> 2, com.Rows >> 2),
                HersheyFonts.HersheyComplex, 2.0,
                new Scalar(2, 2, 2, 0), 2, LineTypes.Link8, false);
        }

        public void AddImageWatermark(Mat com, Mat watermark)
        {
            Mat mask = new Mat();
            Cv2.InRange(watermark, new Scalar(0, 0, 0, 0), new Scalar(0, 0, 0, 0), mask);
            Mat i2 = new Mat(watermark.Size(), watermark.Type(), new Scalar(2, 2, 2, 0));
            i2.CopyTo(watermark, mask);
            watermark.ConvertTo(watermark, MatType.CV_32F);
            int row = (com.Rows - watermark.Rows) >> 1;
            int col = (com.Cols - watermark.Cols) >> 1;
            Cv2.CopyMakeBorder(watermark, watermark, row, row, col, col, BorderTypes.Constant, Scalar.All(0));
            Utils.FixSize(watermark, com);
            Cv2.AddWeighted(watermark, 0.03, com, 1, 0.0, com);
        }

        public Mat ShowWatermark(Mat src)
        {
            src.ConvertTo(src, MatType.CV_8UC3); // COLOR_RGB2HSV requires 8-bit or 16-bit usually, Java code says convertTo(src, COLOR_RGB2HSV). Wait.
            // Java: src.convertTo(src, COLOR_RGB2HSV); 
            // Actually convertTo is for type conversion (e.g. to float). cvtColor is for color space.
            // The Java code in DctConverter.java says: src.convertTo(src, COLOR_RGB2HSV);
            // This looks like a mistake in the Java code or I am misreading. 
            // Core.java doesn't have COLOR_RGB2HSV constant for convertTo. Imgproc has it.
            // Imgproc.cvtColor(src, src, Imgproc.COLOR_RGB2HSV); is the correct way.
            // The Java code provided: `src.convertTo(src, COLOR_RGB2HSV);`
            // `COLOR_RGB2HSV` is an int (usually 40 or 41). `convertTo` takes rtype (int).
            // If they are using `convertTo` with a color conversion code, they might be doing something wrong or it's valid in Java OpenCV to use it as a type? No.
            // `CV_32F` is a type. `COLOR_RGB2HSV` is a conversion code.
            // Let's assume they meant `Imgproc.cvtColor`.
            // Wait, checking the Java code again: `src.convertTo(src, COLOR_RGB2HSV);`
            // If I look at `DctConverter.java` line 76: `src.convertTo(src, COLOR_RGB2HSV);`
            // This is very suspicious.
            // However, `COLOR_RGB2HSV` is likely imported statically from `Imgproc`.
            // In OpenCV C++, `convertTo` changes the depth.
            // I will use `Cv2.CvtColor` because that's what makes sense for HSV.
            
            Cv2.CvtColor(src, src, ColorConversionCodes.RGB2HSV);
            Cv2.InRange(src, new Scalar(0, 0, 0, 0), new Scalar(16, 16, 16, 0), src);
            Cv2.Normalize(src, src, 0, 255, NormTypes.MinMax, (int)MatType.CV_8UC1);
            return src;
        }
    }
}