using System;
using System.Configuration;
using System.Data;
using System.Data.Sql;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Data.OleDb;
using System.Data.SqlClient;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Globalization;
using System.Threading;

namespace NNmarket
{
    class Wskazniki
    {



        public static double[] SMA(double[] tablica, int krok)
        {
            //int poz = pozycja;
            //double[,] tablicaa = tablica;
            // int skrok = krokmin;
            int il_r = tablica.Length;
            double[] srednia_kroczaca = new double[il_r];
            for (int i = 0; i < il_r - krok + 1; i++)
            {
                srednia_kroczaca[i + krok - 1] = 0;
                for (int j = i; j < krok + i; j++)
                {
                    srednia_kroczaca[i + krok - 1] += tablica[j];
                }
                srednia_kroczaca[i + krok - 1] /= krok;
            }
            return srednia_kroczaca;
        }
        public static double[] SygnalySMA(double[] Notowania, double[] SMA)
        {
            double[] sygnaly = new double[Notowania.Length];
            for (int i = 1; i < Notowania.Length - 1; i++)
            {

                double sygnal = 0;
                if ((SMA[i - 1] - SMA[i]) >= 0)
                {
                    if (SMA[i] < Notowania[i] && SMA[i] < Notowania[i] && SMA[i - 1] < Notowania[i]) { sygnal = 1; }
                }
                if ((SMA[i - 1] - SMA[i]) <= 0)
                {
                    if (SMA[i] > Notowania[i] && Notowania[i - 1] > Notowania[i] && SMA[i - 1] > Notowania[i]) { sygnal = -1; }
                }
                else { sygnal = 0; }
                sygnaly[i] = sygnal;
            }

            return sygnaly;

        }
        public static double[] SygnalySMA2(double[] Notowania, double[] SMA)
        {
            

                double[] sygnaly = new double[Notowania.Length];
                for (int i = 1; i < Notowania.Length - 1; i++)
                {

                    double sygnal = 0;
                    if (SMA[i - 1] < Notowania[i-1])
                    {
                        if (SMA[i] > Notowania[i]) { sygnal = 1; }
                    }
                    else if (SMA[i - 1] > Notowania[i - 1])
                    {
                        if (SMA[i] < Notowania[i]) { sygnal = -1; }
                    }
                    else { sygnal = 0; }
                    sygnaly[i] = sygnal;
                }

                return sygnaly;
            

        }
        public static double[] ROC(double[] Notowania, int krok)
        {
            double[] ROC = new double[Notowania.Length];
            for (int i = krok - 1; i < Notowania.Length; i++)
            {
                ROC[i] = 100 * (Notowania[i] - Notowania[i - krok + 1]) / Notowania[i - krok + 1];
            }
            return ROC;

        }
        public static double[] SygnalyROC(double[] ROC, int krok)
        {
            double[] SredniaKorczacaZRoc = Wskazniki.SMA(ROC, krok);
            double[] SygnalyROC = new double[ROC.Length];
            for (int i = krok; i < SredniaKorczacaZRoc.Length; i++)
            {
                if (ROC[i] < SredniaKorczacaZRoc[i]) { SygnalyROC[i] = -1; }
                if (ROC[i] > SredniaKorczacaZRoc[i]) { SygnalyROC[i] = 1; }
            }

            return SygnalyROC;
        }
        public static double[] ATR(double[] Zamkniecie, double[] Max, double[] Min, int okres)
        {

            double[] wynik = new double[Zamkniecie.Length];
            double[] maksymalne = new double[Zamkniecie.Length];
            for (int i = 1; i < Zamkniecie.Length - 1; i++)
            {
                double pocnicza = Math.Max(Math.Abs(Max[i] - Min[i]), Math.Abs(Max[i] - Zamkniecie[i - 1]));
                maksymalne[i] = Math.Max(pocnicza, Math.Abs(Min[i] - Zamkniecie[i - 1]));
            }

            for (int i = 0; i < maksymalne.Length - okres + 1; i++)
            {
                wynik[i + okres - 1] = 0;
                for (int j = i; j < okres + i; j++)
                {
                    wynik[i + okres - 1] += maksymalne[j];
                }
                wynik[i + okres - 1] /= okres;
            }

            return wynik;
        }
        public static double[] SygnalyATR(double[] ATR, double[] Zamkniecie)
        {
            double[] AtrDoCena = new double[ATR.Length];
            double[] SygnalyATR = new double[ATR.Length];
            for (int i = 0; i < ATR.Length; i++)
            {
                AtrDoCena[i] = ATR[i] / Zamkniecie[i];
            }

            for (int i = 0; i < ATR.Length; i++)
            {
                if (AtrDoCena[i] < 0.04) { SygnalyATR[i] = -1; };
                if (AtrDoCena[i] > 0.04) { SygnalyATR[i] = 1; };
            }

            return SygnalyATR;

        }
        public static double[] CCI(double[] Zamkniecie, double[] Max, double[] Min, int okres)
        {
            double[] SrednieZamMaxMin = new double[Zamkniecie.Length];

            for (int i = 0; i < SrednieZamMaxMin.Length; i++)
            {
                SrednieZamMaxMin[i] = (Zamkniecie[i] + Max[i] + Min[i]) / 3;


            }
            double[] srednia = SMA(SrednieZamMaxMin, okres);
            double[] moduly = new double[srednia.Length];
            //int i=0;
            double pomocnicza = 0.00;
            for (int j = 0; j < SrednieZamMaxMin.Length - okres + 1; j++)
            {
                for (int i = j; i < okres + j; i++)
                {
                    pomocnicza = Math.Abs(srednia[j + okres - 1] - SrednieZamMaxMin[i]);
                    moduly[j + okres - 1] += pomocnicza;


                }
                moduly[j + okres - 1] /= okres;
                pomocnicza = 0.00;
            }
            double[] wynik = new double[SrednieZamMaxMin.Length];
            for (int l = 0; l < SrednieZamMaxMin.Length; l++)
            {
                wynik[l] = (SrednieZamMaxMin[l] - srednia[l]) / (0.015 * moduly[l]);
                if (0.015 * moduly[l] == 0.00) { wynik[l] = 0.00; }

            }

            return wynik;


        }
        public static double[] SygnalyCCI(double[] CCI)
        {
            double[] SygnalyCCI = new double[CCI.Length];
            SygnalyCCI[0] = -1.00;
            SygnalyCCI[1] = -1.00;
            for (int i = 2; i < CCI.Length; i++)
            {
                if (CCI[i] < -100.00 && CCI[i - 1] < -100.00 && CCI[i - 2] > -100.00 && SygnalyCCI[i - 1] == 1.00) { SygnalyCCI[i] = -1.00; }
                else
                {
                    if (CCI[i] > 100.00 && CCI[i - 1] > 100.00 && CCI[i - 2] < 100.00 && SygnalyCCI[i - 1] == -1.00) { SygnalyCCI[i] = 1.00; }
                    else { SygnalyCCI[i] = SygnalyCCI[i - 1]; }

                }

            }

            return SygnalyCCI;

        }
        public static double[] RSI(double[] Zamkniecie, int okres)
        {
            double[] Zmiana = new double[Zamkniecie.Length];
            double pomocnicza = 0.00;
            for (int i = 1; i < Zamkniecie.Length; i++)
            {
                Zmiana[i] = Zamkniecie[i] - Zamkniecie[i - 1];

            }

            for (int i = 1; i < okres + 1; i++)
            {
                Zmiana[i] = Math.Abs(Zmiana[i]);
                pomocnicza += Zmiana[i];

            }

            double[] nZmiana = new double[Zmiana.Length];
            double ulamek = 1 / Convert.ToDouble(okres);
            nZmiana[okres] = Zamkniecie[okres] - Zamkniecie[1];
            double pomocnicza2 = 0.00;
            for (int i = okres + 1; i < nZmiana.Length; i++)
            {

                nZmiana[i] = nZmiana[i - 1] + ulamek * (Zmiana[i] - nZmiana[i - 1]);
            }

            double[] tZmiana = new double[Zmiana.Length];
            tZmiana[okres] = pomocnicza / Convert.ToDouble(okres);
            for (int i = okres + 1; i < tZmiana.Length; i++)
            {
                pomocnicza2 = Math.Abs(Zmiana[i]);
                tZmiana[i] = tZmiana[i - 1] + ulamek * (pomocnicza2 - tZmiana[i - 1]);
            }

            double[] wynik = new double[Zmiana.Length];
            wynik[okres] = nZmiana[okres] / tZmiana[okres];
            for (int i = okres + 1; i < wynik.Length; i++)
            {
                if (tZmiana[i] != 0.00) { wynik[i] = nZmiana[i] / tZmiana[i]; }
                else { wynik[i] = 0.00; }
            }

            double[] wynik2 = new double[Zmiana.Length];

            for (int i = okres; i < wynik.Length; i++)
            {
                wynik2[i] = 50 * (wynik[i] + 1);
            }


            return wynik2;
        }
        public static double[] SygnalyRSI(double[] RSI)
        {
            double[] SygnalyRSI = new double[RSI.Length];
            SygnalyRSI[0] = -1.00;
            SygnalyRSI[1] = -1.00;
            for (int i = 2; i < RSI.Length; i++)
            {
                if (RSI[i] > 30.00 && RSI[i - 1] > 30.00 && RSI[i - 2] < 30.00 && SygnalyRSI[i - 1] == -1.00) { SygnalyRSI[i] = 1.00; }
                else
                {
                    if (RSI[i] < 70.00 && RSI[i - 1] < 70.00 && RSI[i - 2] > 70.00 && SygnalyRSI[i - 1] == 1.00) { SygnalyRSI[i] = -1.00; }
                    else { SygnalyRSI[i] = SygnalyRSI[i - 1]; }

                }

            }

            return SygnalyRSI;

        }
        public static double[] SO(double[] Zamkniecie, double[] Max, double[] Min, int okres)
        {
            double[] hMax = new double[Zamkniecie.Length];
            double[] lMin = new double[Zamkniecie.Length];


            for (int i = 0; i < Max.Length - okres + 1; i++)
            {
                double max = 0;
                for (int j = i; j < okres + i; j++)
                {
                    if (Max[j] >= max) { max = Max[j]; };
                }
                hMax[i + okres - 1] = max;
            }


            for (int i = 0; i < Min.Length - okres + 1; i++)
            {
                double min = 100000;
                for (int j = i; j < okres + i; j++)
                {
                    if (Min[j] <= min) { min = Min[j]; };
                }
                lMin[i + okres - 1] = min;
            }


            double[] wynik = new double[Zamkniecie.Length];
            for (int i = 0; i < Zamkniecie.Length; i++)
            {
                wynik[i] = 0.00;
                wynik[i] = (Zamkniecie[i] - lMin[i]) / (hMax[i] - lMin[i]) * 100;
                if (hMax[i] - lMin[i] == 0.00) { wynik[i] = 0.00; }
            }
            return wynik;

        }
        public static double[] SygnalySO(double[] SO)
        {
            double[] SygnalySO = new double[SO.Length];
            SygnalySO[0] = -1.00;
            SygnalySO[1] = -1.00;
            for (int i = 2; i < SO.Length; i++)
            {
                if (SO[i] > 25.00 && SO[i - 1] > 25.00 && SO[i - 2] < 25.00 && SygnalySO[i - 1] == -1.00) { SygnalySO[i] = 1.00; }
                else
                {
                    if (SO[i] < 85.00 && SO[i - 1] < 85.00 && SO[i - 2] > 85.00 && SygnalySO[i - 1] == 1.00) { SygnalySO[i] = -1.00; }
                    else { SygnalySO[i] = SygnalySO[i - 1]; }

                }

            }

            return SygnalySO;

        }
        public static double[] N2(double[] TablicaNotowan)
        {
            double[] wynik = new double[TablicaNotowan.Length];
            for (int i = 4; i < TablicaNotowan.Length; i++)
            {

                wynik[i] = (TablicaNotowan[i - 3] + TablicaNotowan[i - 4]) / 2;


            }
            return wynik;
        }
        public static double[] N4(double[] TablicaNotowan)
        {
            double[] wynik = new double[TablicaNotowan.Length];
            for (int i = 8; i < TablicaNotowan.Length; i++)
            {

                wynik[i] = (TablicaNotowan[i - 5] + TablicaNotowan[i - 6] + TablicaNotowan[i - 7] + TablicaNotowan[i - 8]) / 4;


            }
            return wynik;
        }
        public static double[] N8(double[] TablicaNotowan)
        {
            double[] wynik = new double[TablicaNotowan.Length];
            for (int i = 16; i < TablicaNotowan.Length; i++)
            {
                for (int j = 9; j < 16; j++)
                {
                    wynik[i] += TablicaNotowan[i - j];
                }
                wynik[i] = wynik[i] / 8;
            }
            return wynik;
        }
        public static double[] N16(double[] TablicaNotowan)
        {
            double[] wynik = new double[TablicaNotowan.Length];
            for (int i = 32; i < TablicaNotowan.Length; i++)
            {
                for (int j = 17; j <= 32; j++)
                {
                    wynik[i] += TablicaNotowan[i - j];
                }
                wynik[i] = wynik[i] / 32;
            }
            return wynik;
        }
        public static double[] N32(double[] TablicaNotowan)
        {
            double[] wynik = new double[TablicaNotowan.Length];
            for (int i = 64; i < TablicaNotowan.Length; i++)
            {
                for (int j = 33; j <= 64; j++)
                {
                    wynik[i] += TablicaNotowan[i - j];
                }
                wynik[i] = wynik[i] / 32;
            }
            return wynik;
        }
        public static double[] N64(double[] TablicaNotowan)
        {
            double[] wynik = new double[TablicaNotowan.Length];
            for (int i = 128; i < TablicaNotowan.Length; i++)
            {
                for (int j = 65; j <= 128; j++)
                {
                    wynik[i] += TablicaNotowan[i - j];
                }
                wynik[i] = wynik[i] / 64;
            }
            return wynik;
        }
        public static double[] SygnalySwiece(double[] Otwarcie, double[] Zamkniecie, double[] Maks, double[] Min)
        {
            double[] sygnaly = new double[Otwarcie.Length];

            for (int i = 0; i < Otwarcie.Length - 1; i++)
            {
                string rodzaj = "";
                if (Otwarcie[i] >= Zamkniecie[i]) { rodzaj = "czarna"; }
                if (Otwarcie[i] < Zamkniecie[i]) { rodzaj = "biala"; }
                double z = Zamkniecie[i];
                double o = Otwarcie[i];
                double max = Maks[i];
                double m = Min[i];

                sygnaly[i] = 0;
                if (rodzaj == "czarna" && Maks[i] <= Otwarcie[i] + (0.01 * Otwarcie[i]) && Min[i] <= Zamkniecie[i] - (Otwarcie[i] - Zamkniecie[i])) { sygnaly[i] = 1; }
                if (rodzaj == "biala" && Maks[i] <= Zamkniecie[i] + (0.01 * Zamkniecie[i]) && Min[i] <= Otwarcie[i] - (Zamkniecie[i] - Otwarcie[i])) { sygnaly[i] = 1; }
                if (rodzaj == "czarna" && Maks[i] >= Otwarcie[i] + (Otwarcie[i] - Zamkniecie[i]) && Min[i] >= Zamkniecie[i] - (Zamkniecie[i] * 0.01)) { sygnaly[i] = -1; }
                if (rodzaj == "biala" && Maks[i] >= Zamkniecie[i] + (Zamkniecie[i] - Otwarcie[i]) && Min[i] >= Otwarcie[i] - (Otwarcie[i] * 0.01)) { sygnaly[i] = -1; }

            }

            return sygnaly;


        }
        public static double[] ZmianaWart(double[] Notowaniaw, int CzasWstecz)
        {
            double[] wynik = new double[Notowaniaw.Length];
            double[] Notowania = new double[Notowaniaw.Length];
            Array.Copy(Notowaniaw, Notowania, Notowaniaw.Length);
            for (int i = CzasWstecz; i < Notowania.Length; i++)
            {
                if (Notowania[i - CzasWstecz] == 0) { Notowania[i - CzasWstecz] = 1; }
                wynik[i] = Notowania[i] / Notowania[i - CzasWstecz];


            }

            return wynik;

        }


       

    
    
    
    }
}
