#include <windows.h>
#include <math.h>
#include <stdio.h>
#include "..\header\rozklad.cpp"
#include "..\header\simpson.cpp"
#include "..\header\grin.cpp"

#define ID_BUTTON1 3899
#define ID_BUTTON2 3999
#define ID_BUTTON3 4000

                   // przestrzen zmiennych globalnych i funkcji z ktorych korzysta
                   // funkcja rysujaca histogram
namespace histogram
{
 long int k = 10000;
 long int L = 30;

 long int licznosc(double a, double b, double x[]);

 int sort_function(const void* a, const void* b);

 bool rysuj_histogram = false;

}

void histogram_rozkladu_odwrotnego_normalnego(HDC hdc,int cx,int cy);

//---------------zmienne globalne----------------------------------------------


const double h = 0.01;

static double mi  = 5.0;
static double sigma  = 5.0;                     // a > 0 b>=0
static double mi1 = 5.0;
static double sigma1 = 5.0;
static double wsk_mi = mi;
static double wsk_sigma = sigma;

static const  double A = 0.0 + h;
static const  double B = 3.0;

static const long int il_h = (B-A)/h + 1;

static const double f_max_wykresu = 3.0;

static double f_max_rozkladu = 0.0;

ROZKLAD* INV = new ROZKLAD[il_h];
POINT*   PW  = new POINT[il_h];
POINT*   PD  = new POINT[il_h];

static char   buff[6];     //bufor textowy do przechwytu wartosci a
static char*  endptr;      //adres znaku w buforze ktory spowodowal blad

double h1 = 0.4;

//----------deklaracje funkcji---------------------------------------------
double dINf(double x);

void rys_wsp(HDC hdc,int cx,int cy);

void rys_wykresy(HDC hdc,int cx,int cy);

//--------------------------------------------------------------------------


LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    PSTR szCmdLine, int iCmdShow)
{
     static TCHAR szAppName[] = " ";
     HWND         hwnd;
     MSG          msg ;
     WNDCLASS     wndclass ;

     wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
     wndclass.lpfnWndProc   = WndProc ;
     wndclass.cbClsExtra    = 0 ;
     wndclass.cbWndExtra    = 0 ;
     wndclass.hInstance     = hInstance ;
     wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
     wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     wndclass.lpszMenuName  = NULL ;
     wndclass.lpszClassName = szAppName ;

     if (!RegisterClass (&wndclass))
     {
          MessageBox (NULL, TEXT ("Program requires Windows NT!"),
                      szAppName, MB_ICONERROR) ;
          return 0 ;
     }

     hwnd = CreateWindow (szAppName, TEXT ("Rozklad gaussowski odwrotny"),
                          WS_OVERLAPPEDWINDOW,
                          0, 0,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          NULL, NULL, hInstance, NULL);

     ShowWindow (hwnd, iCmdShow) ;
     UpdateWindow (hwnd) ;

     while (GetMessage (&msg, NULL, 0, 0))
     {
          TranslateMessage (&msg) ;
          DispatchMessage (&msg) ;
     }


     return msg.wParam ;
}

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{

 static HDC         hdc ;
 static HINSTANCE   hinstance;
 static HWND        edit_mi,  edit_sigma, button1, button2, button3,
                    edit_mi1, edit_sigma1,
                    edit_h1,
                    edit_liczby_losowe,
                    edit_ilosc_przedzialow;

 static int  cx ;
 static int  cy ;

 static PAINTSTRUCT ps ;
 static RECT kwadrat;

//-----------------------------------------------------------------------------

     switch (message)
     {
     case WM_SIZE:
          cx = LOWORD (lParam) ;
          cy = HIWORD (lParam) ;

          kwadrat.left   = 0;
          kwadrat.top    = cy /4;
          kwadrat.right  = cx;
          kwadrat.bottom = cy;
          return 0 ;


     case WM_CREATE:

             hinstance = ((LPCREATESTRUCT)lParam)->hInstance;
           //-------
             edit_mi = CreateWindowEx(WS_EX_CLIENTEDGE, "EDIT", "5.00",
                                     WS_CHILD | WS_VISIBLE | WS_BORDER,
		                               50, 60, 40, 22,
                                     hwnd, NULL, hinstance, NULL);
           //--------
	          edit_sigma = CreateWindowEx(WS_EX_CLIENTEDGE, "EDIT", "5.00",
                                     WS_CHILD | WS_VISIBLE | WS_BORDER,
                                     50, 100, 40, 22,
                                     hwnd, NULL,hinstance, NULL);
           //--------
             edit_mi1 = CreateWindowEx(WS_EX_CLIENTEDGE, "EDIT", "5.00",
                                     WS_CHILD | WS_VISIBLE | WS_BORDER,
		                               150, 60, 40, 22,
                                     hwnd, NULL, hinstance, NULL);
           //---------
             edit_sigma1 = CreateWindowEx(WS_EX_CLIENTEDGE, "EDIT", "5.00",
                                     WS_CHILD | WS_VISIBLE | WS_BORDER,
                                     150, 100, 40, 22,
                                     hwnd, NULL,hinstance, NULL);


             edit_h1 = CreateWindowEx(WS_EX_CLIENTEDGE, "EDIT", "0.40",
                                    WS_CHILD | WS_VISIBLE | WS_BORDER,
		                              110, 140, 40, 22,
                                    hwnd, NULL, hinstance, NULL);
             edit_liczby_losowe = CreateWindowEx(WS_EX_CLIENTEDGE, "EDIT", "10000",
                                    WS_CHILD | WS_VISIBLE | WS_BORDER,
		                              610, 80, 50, 22,
                                    hwnd, NULL, hinstance, NULL);
             edit_ilosc_przedzialow = CreateWindowEx(WS_EX_CLIENTEDGE, "EDIT", "30",
                                    WS_CHILD | WS_VISIBLE | WS_BORDER,
		                              610, 110, 40, 22,
                                    hwnd, NULL, hinstance, NULL);


             button1 = CreateWindowEx(WS_EX_CLIENTEDGE,"button","Rysuj",
                                      WS_CHILD | WS_VISIBLE,
			                             200, 100, 50, 25,
                                      hwnd,(HMENU)ID_BUTTON1, hinstance, NULL);

             button2 = CreateWindowEx(WS_EX_CLIENTEDGE,"button","Wartosci",
                                      WS_CHILD | WS_VISIBLE,
			                             300, 100, 100, 25,
                                      hwnd,(HMENU)ID_BUTTON2, hinstance, NULL);

             button3 = CreateWindowEx(WS_EX_CLIENTEDGE,"button","Histogram",
                                      WS_CHILD | WS_VISIBLE,
			                             500, 50, 90, 23,
                                      hwnd,(HMENU)ID_BUTTON3, hinstance, NULL);


          return 0;

     case WM_COMMAND:

			switch(wParam)
			{
            case ID_BUTTON1:
//------------------------------------------------------------------------------
             SendMessage(edit_mi,WM_GETTEXT,5,(LPARAM)buff);
				 strtod(buff, &endptr);

              if(*endptr != NULL){
                 MessageBox (hwnd, TEXT ("bledny format liczby"),
                             TEXT("Blad krytyczny"), MB_ICONERROR) ;
                 SendMessage(edit_mi,WM_SETTEXT,0,(LPARAM)TEXT("5.00"));
                }
             SendMessage(edit_mi,WM_GETTEXT,5,(LPARAM)buff);
             mi = strtod(buff, &endptr);

//------------------------------------------------------------------------------
             SendMessage(edit_sigma,WM_GETTEXT,5,(LPARAM)buff);
				 strtod(buff, &endptr);

              if(*endptr != NULL){
                 MessageBox (hwnd, TEXT ("bledny format liczby"),
                             TEXT("Blad krytyczny"), MB_ICONERROR) ;
                 SendMessage(edit_sigma,WM_SETTEXT,0,(LPARAM)TEXT("5.00"));
                }
             SendMessage(edit_sigma,WM_GETTEXT,5,(LPARAM)buff);
             sigma = strtod(buff, &endptr);

              if (sigma <= 0){
                 MessageBox (hwnd, TEXT ("parametr sigma musi byc > 0"),
                             TEXT("Blad krytyczny"), MB_ICONERROR) ;
                 sigma = 5.0;
                 SendMessage(edit_sigma,WM_SETTEXT,0,(LPARAM)TEXT("5.00"));
                 }

//------------------------------------------------------------------------------
             SendMessage(edit_mi1,WM_GETTEXT,5,(LPARAM)buff);
				 strtod(buff, &endptr);

              if(*endptr != NULL){
                 MessageBox (hwnd, TEXT ("bledny format liczby"),
                             TEXT("Blad krytyczny"), MB_ICONERROR) ;
                 SendMessage(edit_mi1,WM_SETTEXT,0,(LPARAM)TEXT("5.00"));
                }
             SendMessage(edit_mi1,WM_GETTEXT,5,(LPARAM)buff);
             mi1 = strtod(buff, &endptr);

//------------------------------------------------------------------------------
             SendMessage(edit_sigma1,WM_GETTEXT,5,(LPARAM)buff);
				 strtod(buff, &endptr);

              if(*endptr != NULL){
                 MessageBox (hwnd, TEXT ("bledny format liczby"),
                             TEXT("Blad krytyczny"), MB_ICONERROR) ;
                 SendMessage(edit_sigma1,WM_SETTEXT,0,(LPARAM)TEXT("5.00"));
                }
             SendMessage(edit_sigma1,WM_GETTEXT,5,(LPARAM)buff);
             sigma1 = strtod(buff, &endptr);

//------------------------------------------------------------------------------
             SendMessage(edit_h1,WM_GETTEXT,5,(LPARAM)buff);
             strtod(buff, &endptr);

              if(*endptr != NULL){
                 MessageBox (hwnd, TEXT ("bledny format liczby"),
                             TEXT("Blad krytyczny"), MB_ICONERROR) ;
                 SendMessage(edit_h1,WM_SETTEXT,0,(LPARAM)TEXT("0.20"));
                }
             SendMessage(edit_h1,WM_GETTEXT,5,(LPARAM)buff);
             h1 = strtod(buff, &endptr);

              if (h1 <= 0){
                 MessageBox (hwnd, TEXT ("rozdzielczosc musi byc > 0 "),
                             TEXT("Blad krytyczny"), MB_ICONERROR) ;
                  h1 = 0.2;
                 SendMessage(edit_h1,WM_SETTEXT,0,(LPARAM)TEXT("0.20"));
                 }

//------------------------------------------------------------------------------
              if ( (mi > mi1) || (sigma > sigma1) ){
                 MessageBox (hwnd,
                 TEXT ("parametry sigma1 i mi1 musza byc wieksze od mi i sigma"),
                 TEXT("Blad krytyczny"), MB_ICONERROR) ;

                  mi = mi1 = 5.0;
                  sigma = sigma1 = 5.0;

                 SendMessage(edit_mi,    WM_SETTEXT,0,(LPARAM)TEXT("5.00"));
                 SendMessage(edit_mi1,   WM_SETTEXT,0,(LPARAM)TEXT("5.00"));
                 SendMessage(edit_sigma, WM_SETTEXT,0,(LPARAM)TEXT("5.00"));
                 SendMessage(edit_sigma1,WM_SETTEXT,0,(LPARAM)TEXT("5.00"));
                 }

               histogram::rysuj_histogram = false;
               InvalidateRect(hwnd, &kwadrat,TRUE);
              break;

           case ID_BUTTON2:

              wartosci_rozkladu(hwnd, INV, il_h);

             break;
           case ID_BUTTON3:

             SendMessage(edit_liczby_losowe,WM_GETTEXT,5,(LPARAM)buff);
				 strtod(buff, &endptr);

              if(*endptr != NULL){
                 MessageBox (hwnd, TEXT ("bledny format liczby"),
                             TEXT("Blad krytyczny"), MB_ICONERROR) ;
                 SendMessage(edit_liczby_losowe,WM_SETTEXT,0,(LPARAM)TEXT("1000"));
                }
             SendMessage(edit_liczby_losowe,WM_GETTEXT,5,(LPARAM)buff);
             histogram::k = strtod(buff, &endptr);

             SendMessage(edit_ilosc_przedzialow,WM_GETTEXT,5,(LPARAM)buff);
				 strtod(buff, &endptr);

              if(*endptr != NULL){
                 MessageBox (hwnd, TEXT ("bledny format liczby"),
                             TEXT("Blad krytyczny"), MB_ICONERROR) ;
                 SendMessage(edit_ilosc_przedzialow,WM_SETTEXT,0,(LPARAM)TEXT("10"));
                }
             SendMessage(edit_ilosc_przedzialow,WM_GETTEXT,5,(LPARAM)buff);
             histogram::L = strtod(buff, &endptr);


             histogram::rysuj_histogram = true;

            InvalidateRect(hwnd, &kwadrat,TRUE);
             break;

         }

		break;

     case WM_PAINT:
          hdc = BeginPaint (hwnd, &ps) ;
 //---------------------------TEXTY-------------------------------------------
          TextOut(hdc, 5,  2, "Rozklad gaussowski odwrotny z parametrami mi i sigma  (mi > 0, sigma >= 0) dziedzina funkcji (0, 3)",99);
          TextOut(hdc, 5, 25, "Rysunek wielowykresowy w zakresie od mi -> mi1 i sigma -> sigma1 przy zadanej rozdzielczosci (mi >= mi1, sigma >= sigma1)",121);
          TextOut(hdc, 5, 62,  "     mi                    mi1",30);
          TextOut(hdc, 5, 102, "sigma =           sigma1",25);
          TextOut(hdc, 5, 140, "Rozdzieczosc",12);
          TextOut(hdc, 500, 80, "Liczby losowe",13);
          TextOut(hdc, 490, 110, "ilosc przedzialow",17);
 //----------------------------------------------------------------------------

           wsk_mi = mi;
           wsk_sigma = sigma;

            while(wsk_mi <= mi1)
            {
              while(wsk_sigma <= sigma1)
               {
                rys_wykresy(hdc,cx,cy);
                wsk_sigma +=h1;
               }
             wsk_sigma = sigma;
             wsk_mi +=h1;
            }

        if( histogram::rysuj_histogram ){
            histogram_rozkladu_odwrotnego_normalnego(hdc, cx, cy);
           }

          rys_wsp(hdc,cx,cy);

          EndPaint(hwnd, &ps);
//-----------------------------------------------------------------------------
          return 0 ;

     case WM_DESTROY:

          delete[] INV;
          delete[] PW;
          delete[] PD;

          PostQuitMessage (0) ;
          return 0 ;
     }

     return DefWindowProc (hwnd, message, wParam, lParam) ;
}
//----------------------------------------------------------------------


void rys_wsp(HDC hdc,int cx,int cy)
{
 //---------------------------------------------------
             MoveToEx (hdc,    0, cy/4, NULL);
             LineTo   (hdc,   cx, cy/4);
    //       MoveToEx (hdc, cx/2,    0, NULL);
    //       LineTo   (hdc, cx/2,   cy);

//------------------liczby--------------------------------------
          TextOut(hdc, 2,(cy-20) - ((cy/2-20+6)/3), "--1",3);
          TextOut(hdc, 2,(cy-20) - ((cy/2-20+6)/3*2), "--2",3);
          TextOut(hdc, 2,(cy-20) -  (cy/2-20+6), "--3",3);

          TextOut(hdc, 2+cx/2,(cy-20) - (cy/2-20+6), "--1",3);

          TextOut(hdc,             0,(cy-15), "0",1);
          TextOut(hdc, (cx/2-10)/3/2,(cy-15), "0.5",3);
          TextOut(hdc, (cx/2-10)/3  ,(cy-15), "1",1);
          TextOut(hdc, (cx/2-10)/3*2,(cy-15), "2",1);
          TextOut(hdc, (cx/2-10)    ,(cy-15), "3",1);

          TextOut(hdc,               cx/2+5,(cy-15), "0",1);
          TextOut(hdc, (cx/2-10)/3/2+cx/2+5,(cy-15), "0.5",3);
          TextOut(hdc, (cx/2-10)/3  +cx/2+5,(cy-15), "1",1);
          TextOut(hdc, (cx/2-10)/3*2+cx/2+5,(cy-15), "2",1);
          TextOut(hdc, (cx/2-10)    +cx/2,(cy-15), "3",1);

          TextOut(hdc,     20,cy/2-20,"f(x)",4);
          TextOut(hdc,cx/2+20,cy/2-20,"F(x)",4);

//-----wykres 2 cwartka okna--------------------------

          MoveToEx (hdc,      0,   cy-20, NULL);
          LineTo   (hdc,   cx/2,   cy-20);        //OX
          MoveToEx (hdc,      5, cy-20, NULL);
          LineTo   (hdc,      5, cy/2-20);     //OY

          MoveToEx (hdc,       0,   cy-20, NULL);
          LineTo   (hdc,      10,   cy-30);        //strzalka ox lewa
          MoveToEx (hdc,       0,   cy-20, NULL);
          LineTo   (hdc,      10,   cy-10);

          MoveToEx (hdc,    cx/2,   cy-20, NULL);
          LineTo   (hdc, cx/2-10,   cy-30);       //strzalka ox prawa
          MoveToEx (hdc,    cx/2,   cy-20, NULL);
          LineTo   (hdc, cx/2-10,   cy-10);

          MoveToEx (hdc,       5,    cy/2-20, NULL);
          LineTo   (hdc,      15,    cy/2-10);       //strzalka oy
          MoveToEx (hdc,       5,    cy/2-20, NULL);
          LineTo   (hdc,       0,    cy/2-15);

//--------wykres 1 cwartka---przesyniecie poprzedniego o vector [cx/2+5,0]

          MoveToEx (hdc,      0 +cx/2+5,  cy-20, NULL);
          LineTo   (hdc,   cx/2 +cx/2,    cy-20);        //OX
          MoveToEx (hdc,         cx/2+5,  cy-20, NULL);
          LineTo   (hdc,         cx/2+5,  cy/2-20);        //OY

          MoveToEx (hdc,       0 +cx/2+5,   cy-20, NULL);
          LineTo   (hdc,      10 +cx/2+5,   cy-30);
          MoveToEx (hdc,       0 +cx/2+5,   cy-20, NULL);
          LineTo   (hdc,      10 +cx/2+5,   cy-10);

          MoveToEx (hdc,    cx/2 +cx/2,   cy-20, NULL);
          LineTo   (hdc, cx/2-10 +cx/2,   cy-30);
          MoveToEx (hdc,    cx/2 +cx/2,   cy-20, NULL);
          LineTo   (hdc, cx/2-10 +cx/2,   cy-10);

          MoveToEx (hdc,       0 +cx/2+5,    cy/2-20, NULL);
          LineTo   (hdc,       0 +cx/2+5+10, cy/2-10);
          MoveToEx (hdc,       0 +cx/2+5,    cy/2-20, NULL);
          LineTo   (hdc,       0 +cx/2+5-10, cy/2+10-20);

}

//----------------------------------------------------------

double dINf(double x)

{                                   //funkcja gestosci rozkladu
   return (wsk_mi/sqrt(2*M_PI)) *
          (1/sqrt(x*x*x)) * exp(-(((wsk_sigma*x-wsk_mi)*(wsk_sigma*x-wsk_mi))/(2*x)) );
}

//-------------------------------------------------------------

void rys_wykresy(HDC hdc,int cx,int cy)
{
  f_max_rozkladu = 0.0;

    for(int i=0; i<il_h; i++)
    {
      INV[i].x = A + i*h;
      INV[i].y = dINf( INV[i].x );

     if( f_max_rozkladu < INV[i].y ) f_max_rozkladu = INV[i].y;

      INV[i].F = i ? INV[i-1].F  +
                     Simpson( INV[i-1].x, INV[i].x ,dINf )  : 0.0;
    }


    for(int i=0;i<il_h;i++)
    {
     PW[i].x = (int) ( (cx/2)/B*(INV[i].x) );
     PW[i].y = (int) ( (cy-20) - ((cy/2-20)/f_max_wykresu * INV[i].y) );

     PD[i].x = (int) ( (cx/2)/B*(INV[i].x) ) + cx/2+5;  //przesun o vector [cx/2+5,0]
     PD[i].y = (int) ( (cy-20) - (cy/2-20)*INV[i].F );
    }

   Polyline (hdc, PW, il_h) ;
   Polyline (hdc, PD, il_h) ;
}


void histogram_rozkladu_odwrotnego_normalnego(HDC hdc,int cx,int cy)
{
  using namespace histogram;

                    // tablica zmiennych losowych
  double* x = new double[k];

                   // wygeneruj probe losowa o ilosci k
   inv_normal_start(mi,sigma);
   for(long int i=0; i<k; i++)
   {
      x[i] = inv_normal_rand();
   }
   inv_normal_niszcz();


                   // uporzadkuj ciag w monotonicznie niemalejacy
  qsort((double*) x, k, sizeof(x[0]), sort_function);

                   // krance przedzialu ciagu uporzadkowanego
  double a = x[0];
  double b = x[k-1];

                   // dlugosc podprzedzialow
  double h = (b-a)/L;

                   // tablica Histogramu
  double* H = new double[L];

                   // wylicz Histogram dla zmiennej losowej x oraz maksimum
  double Hmax = 0.0;
  for(int i=0; i<L; i++)
  {
   H[i] = (double) licznosc(a+i*h, a+(i+1)*h, x) / k;
   if( Hmax<H[i] ) Hmax = H[i];
  }

                   // tablica funkcji histogramu
  punkt* p = new punkt[L];

                   // skalowanie Histogramu w stosunku do wykresu gestosci
 for(int i=0; i<L; i++)
 {
  p[i].y = (H[i] * f_max_rozkladu)/Hmax;   //H[i]*f_max_rozkladu / Hmax
  p[i].x = a+i*h;
 }

                   // skalowanie w stosunku do rozdzielczosci
 POINT* PH = new POINT[L];
 for(int i=0; i<L; i++)
 {
  PH[i].x = (int) ( (cx/2)/ B * (p[i].x) );
  PH[i].y = (int) ( (cy-20) - ((cy/2-20)/f_max_wykresu * p[i].y) );
 }

                   // rysuj slupki histogramu
  for(int i=0; i<(L-1); i++)
  {
   Rectangle(hdc, PH[i].x, PH[i].y, PH[i+1].x,(cy-20) );
  }

 delete[] x;
 delete[] H;
 delete[] p;
 delete[] PH;
}


int histogram::sort_function(const void* a, const void* b)
{
  double* elem1 = (double *) a;
  double* elem2 = (double *) b;

  if( *elem1<*elem2 ){ return -1; }
  else if ( *elem1==*elem2 ){ return 0; }

 return 1;
}

long int histogram::licznosc(double a, double b, double x[])
{
  long int li = 0;

  for(long int i=0; i<k; i++)
   if( (a<x[i]) && (x[i]<b) ){
    li += 1;
   }

 return li;
}