using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Cudafy;
using Cudafy.Host;
using Cudafy.Translator;

namespace Zadanie_1
{
    public partial class Form1 : Form
    {
        static CudafyModule km = CudafyTranslator.Cudafy();
        static GPGPU gpu = CudafyHost.GetDevice(CudafyModes.Target);
        const int MAXITER = 255;
        const double XMAX = 0.7;
        const double XMIN = -2;
        const double YMIN = -1.2;
        const double YMAX = 1.2;
        const double YSTEP = 0.005;
        const double XSTEP = 0.005;
        const int SIZE = 640;
        
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            gpu.LoadModule(km);

            // Create a new bitmap.
            Bitmap bmp = new Bitmap(640, 640);

            // Lock the bitmap's bits.  
            Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
            System.Drawing.Imaging.BitmapData bmpData =
                bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite,
                bmp.PixelFormat);

            // Get the address of the first line.
            IntPtr ptr = bmpData.Scan0;

            // Declare an array to hold the bytes of the bitmap. 
            int bytes = Math.Abs(bmpData.Stride) * bmp.Height;
            byte[] rgbValues = new byte[bytes];
            byte[] rgb = gpu.Allocate<byte>(bytes);

            gpu.Launch(new dim3(640), new dim3(640), "GetMas", rgb);
            gpu.CopyFromDevice(rgb, rgbValues);

            // Copy the RGB values back to the bitmap
            System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, bytes);

            // Unlock the bits.
            bmp.UnlockBits(bmpData);

            pictureBox1.Image = bmp;
            gpu.FreeAll();
        }

        [Cudafy]
        public static void GetMas(GThread thread, byte[] rgb)
        {
            int x = thread.threadIdx.x;
            int y = thread.blockIdx.x;

            double stepX = Math.Abs(XMAX - XMIN) / SIZE;
            double stepY = Math.Abs(YMAX - YMIN) / SIZE;

            double yc = XMIN + x * stepX;
            double xc = YMIN + y * stepY;
            byte iterations = 0;
            double yTemp1 = yc;
            double xTemp = xc;
            double yTemp2;
            double arg = (yc * yc) + (xc * xc);

            while ((arg < 10000) && (iterations < MAXITER))
            {
                yTemp2 = (yTemp1 * yTemp1) - (xTemp * xTemp) + yc;
                xTemp = (2 * yTemp1 * xTemp) + xc;
                yTemp1 = yTemp2;
                arg = (yTemp1 * yTemp1) + (xTemp * xTemp);
                iterations += 1;
            }

            rgb[y * SIZE * 4 + x * 4] = 0;
            rgb[y * SIZE * 4 + x * 4 + 1] = 0;
            rgb[y * SIZE * 4 + x * 4 + 2] = 0;
            rgb[y * SIZE * 4 + x * 4 + 3] = iterations;
        }
    }
}