/AutoSzkola/AutoSzkola/DataObjects/Kurs.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows.Forms;



namespace EE4IT.AutoSzkola

{

    public class Kurs

    {

        public long Id { get; set; }

        public long KursantId { get; set; }

        public KursTyp TypKursu { get; set; }

        public DateTime DataDodania { get; set; }

        public User UzytkownikDodajacy { get; set; }

        public Instruktor Instruktor { get; set; }

        public Double Cena { get; set; }

        public DateTime Rata1Data { get; set; }

        public DateTime Rata2Data { get; set; }

        public DateTime Rata3Data { get; set; }

        public DateTime Rata4Data { get; set; }

        public DateTime Rata5Data { get; set; }

        public DateTime Rata6Data { get; set; }

        public DateTime Rata7Data { get; set; }

        public DateTime Rata8Data { get; set; }

        public DateTime Rata9Data { get; set; }

        public DateTime Rata10Data { get; set; }

        public bool Rata1Gotowka { get; set; }

        public bool Rata2Gotowka { get; set; }

        public bool Rata3Gotowka { get; set; }

        public bool Rata4Gotowka { get; set; }

        public bool Rata5Gotowka { get; set; }

        public bool Rata6Gotowka { get; set; }

        public bool Rata7Gotowka { get; set; }

        public bool Rata8Gotowka { get; set; }

        public bool Rata9Gotowka { get; set; }

        public bool Rata10Gotowka { get; set; }

        public User Rata1Wprowadzajacy { get; set; }

        public User Rata2Wprowadzajacy { get; set; }

        public User Rata3Wprowadzajacy { get; set; }

        public User Rata4Wprowadzajacy { get; set; }

        public User Rata5Wprowadzajacy { get; set; }

        public User Rata6Wprowadzajacy { get; set; }

        public User Rata7Wprowadzajacy { get; set; }

        public User Rata8Wprowadzajacy { get; set; }

        public User Rata9Wprowadzajacy { get; set; }

        public User Rata10Wprowadzajacy { get; set; }

        public Double Rata1Kwota { get; set; }

        public Double Rata2Kwota { get; set; }

        public Double Rata3Kwota { get; set; }

        public Double Rata4Kwota { get; set; }

        public Double Rata5Kwota { get; set; }

        public Double Rata6Kwota { get; set; }

        public Double Rata7Kwota { get; set; }

        public Double Rata8Kwota { get; set; }

        public Double Rata9Kwota { get; set; }

        public Double Rata10Kwota { get; set; }

        public Boolean Aktywny { get; set; }

        public String Komentarz { get; set; }

        public String NumerZaswiadczenia { get; set; }





        public DateTime Wydruk_1_data { get; set; }

        public User Wydruk_1_Wprowadzajacy { get; set; }



        public DateTime Wydruk_2_data { get; set; }

        public User Wydruk_2_Wprowadzajacy { get; set; }



        public DateTime Wydruk_3_data { get; set; }

        public User Wydruk_3_Wprowadzajacy { get; set; }



        public List<KursGodzina> GodzinyJazdy { get; set; }

        public List<KursGodzina> GodzinyTeorii { get; set; }

        public List<KursGodzina> GodzinyDodatkowe { get; set; }

        public List<KursGodzina> GodzinyEgzaminJazda { get; set; }

        public List<KursGodzina> GodzinyEgzaminTeoria { get; set; }



        public Double SumaRat { get { return Rata1Kwota + Rata2Kwota + Rata3Kwota + Rata4Kwota + Rata5Kwota + Rata6Kwota + Rata7Kwota + Rata8Kwota + Rata9Kwota + Rata10Kwota; } }



        public override string ToString()

        {

            return TypKursu.ToString();

        }



        public string ToString(string format)

        {

            return TypKursu.ToString(format);

        }

        

        public Kurs()

        {

            Rata1Data = DateTime.MaxValue;

            Rata2Data = DateTime.MaxValue;

            Rata3Data = DateTime.MaxValue;

            Rata4Data = DateTime.MaxValue;

            Rata5Data = DateTime.MaxValue;

            Rata6Data = DateTime.MaxValue;

            Rata7Data = DateTime.MaxValue;

            Rata8Data = DateTime.MaxValue;

            Rata9Data = DateTime.MaxValue;

            Rata10Data = DateTime.MaxValue;

            Rata1Gotowka = true;

            Rata2Gotowka = true;

            Rata3Gotowka = true;

            Rata4Gotowka = true;

            Rata5Gotowka = true;

            Rata6Gotowka = true;

            Rata7Gotowka = true;

            Rata8Gotowka = true;

            Rata9Gotowka = true;

            Rata10Gotowka = true;

            Rata1Wprowadzajacy = new User();

            Rata2Wprowadzajacy = new User();

            Rata3Wprowadzajacy = new User();

            Rata4Wprowadzajacy = new User();

            Rata5Wprowadzajacy = new User();

            Rata6Wprowadzajacy = new User();

            Rata7Wprowadzajacy = new User();

            Rata8Wprowadzajacy = new User();

            Rata9Wprowadzajacy = new User();

            Rata10Wprowadzajacy = new User();

            Rata1Kwota = 0;

            Rata2Kwota = 0;

            Rata3Kwota = 0;

            Rata4Kwota = 0;

            Rata5Kwota = 0;

            Rata6Kwota = 0;

            Rata7Kwota = 0;

            Rata8Kwota = 0;

            Rata9Kwota = 0;

            Rata10Kwota = 0;

            Aktywny = true;



            Wydruk_1_Wprowadzajacy = new User();

            Wydruk_2_Wprowadzajacy = new User();

            Wydruk_3_Wprowadzajacy = new User();

            Wydruk_1_data = DateTime.MaxValue;

            Wydruk_2_data = DateTime.MaxValue;

            Wydruk_3_data = DateTime.MaxValue;

        }



        public bool NeedSend()

        {

            return TypKursu.IsRemainder && (NeedSendPrint1() || NeedSendPrint2() || NeedSendPrint3());

        }



        //wprowadzona jest godzina jazdy i godzina teorii a nie ma ustawionej daty 

        public bool NeedSendPrint1()

        {

            int count = 0;



            //zmiana od sierpnia - nie wysylamy z pierwsza jazda

            //if (Wydruk_1_data == DateTime.MaxValue && (GodzinyTeorii.FindAll(o => o.Aktywna).Count > 0 || GodzinyJazdy.FindAll(o => o.Aktywna).Count > 0))

            if (Wydruk_1_data == DateTime.MaxValue && (GodzinyTeorii.FindAll(o => o.Aktywna).Count > 0))

            {

                count = 2;

                //if (GetNoOfHours(GodzinaTyp.TEORIA) > 0)

                //{

                //    if (GetMinDateTimeForTypGodziny(GodzinaTyp.TEORIA).HasValue && GetMinDateTimeForTypGodziny(GodzinaTyp.TEORIA).Value.CompareTo(DateTime.MinValue) > 0)

                //        count++;

                //}



                //if (GetNoOfHours(GodzinaTyp.JAZDA) > 0)

                //{

                //    if (GetMinDateTimeForTypGodziny(GodzinaTyp.JAZDA).HasValue && GetMinDateTimeForTypGodziny(GodzinaTyp.JAZDA).Value.CompareTo(DateTime.MinValue) > 0)

                //        count++;

                //}

            }



            return count == 2;

        }



        //Trzy dni wcześniej o egzaminie wewnętrznym(teoria lub praktyka)

        public bool NeedSendPrint2()

        {

            bool res = false;



            //if (Wydruk_2_data == DateTime.MaxValue && (GetNoOfHours(GodzinaTyp.ETEORIA) > 0 || GetNoOfHours(GodzinaTyp.EJAZDA) > 0 ))

            // egzamin wewnetrzny - nie ma wymogu

            //if (Wydruk_2_data == DateTime.MaxValue && (GodzinyEgzaminTeoria.FindAll(o => o.Aktywna).Count > 0 || GodzinyEgzaminJazda.FindAll(o => o.Aktywna).Count > 0))

            //{

            //    res = true;

            //}



            return res;

        }



        //Osoby które zakończyły szkolenie(w/g ustawy mamy na to 2 tygodnie)

        public bool NeedSendPrint3()

        {

            return Wydruk_3_data == DateTime.MaxValue && GetEndDateTime().CompareTo(DateTime.MinValue) > 0 && GetEndDateTime().AddHours(1).CompareTo(DateTime.Now) <= 0;

        }



        /// <summary>

        /// Number of active assigned hours of given course which are already done

        /// </summary>

        /// <param name="godzinaTyp"></param>

        /// <returns></returns>

        public int GetNoOfHours(GodzinaTyp godzinaTyp)

        {

            int ret = 0;

            switch (godzinaTyp)

            {

                case GodzinaTyp.DODATKOWA:

                    if (GodzinyDodatkowe != null)

                    {

                        ret = GodzinyDodatkowe.FindAll(o => o.Czas < DateTime.Now && o.Aktywna).Count;

                    }

                    break;

                case GodzinaTyp.JAZDA:

                    if (GodzinyJazdy != null)

                    {

                        ret = GodzinyJazdy.FindAll(o => o.Czas < DateTime.Now && o.Aktywna).Count;

                    }

                    break;

                case GodzinaTyp.TEORIA:

                    if (GodzinyTeorii != null)

                    {

                        ret = GodzinyTeorii.FindAll(o => o.Czas < DateTime.Now && o.Aktywna).Count;

                    }

                    break;

                case GodzinaTyp.EJAZDA:

                    if (GodzinyEgzaminJazda != null)

                    {

                        ret = GodzinyEgzaminJazda.FindAll(o => o.Czas < DateTime.Now && o.Aktywna).Count;

                    }

                    break;

                case GodzinaTyp.ETEORIA:

                    if (GodzinyEgzaminTeoria != null)

                    {

                        ret = GodzinyEgzaminTeoria.FindAll(o => o.Czas < DateTime.Now && o.Aktywna).Count;

                    }

                    break;

            }



            return ret;

        }



        public Double GetCurrValueOfKurs()

        {

            Double cenaJazda = 0;

            Double cenaTeoria = 0;

            Double cenaEgzaminJazda = 0;

            Double cenaEgzaminTeoria = 0;

            Double cenaDodatkowa = 0;



            if (GodzinyJazdy != null)

            {

                List<KursGodzina> listJ = GodzinyJazdy.FindAll(o => o.Czas < DateTime.Now && o.Aktywna);

                //cenaJazda = (Double)(listJ.Count * TypKursu.GetCenaJazda());

                foreach (KursGodzina kursGodzina in listJ)

                    cenaJazda += TypKursu.GetCenaJazda(kursGodzina.Czas);

            }



            if (GodzinyTeorii != null)

            {

                List<KursGodzina> listT = GodzinyTeorii.FindAll(o => o.Czas < DateTime.Now && o.Aktywna);

                //cenaTeoria = (Double)(listT.Count * TypKursu.GetCenaTeoria());

                foreach (KursGodzina kursGodzina in listT)

                    cenaTeoria += TypKursu.GetCenaTeoria(kursGodzina.Czas);

            }



            if (GodzinyDodatkowe != null)

            {

                List<KursGodzina> listD = GodzinyDodatkowe.FindAll(o => o.Czas < DateTime.Now && o.Aktywna);

                //cenaDodatkowa = (Double)(listD.Count * TypKursu.GetCenaDodatkowa());

                foreach (KursGodzina kursGodzina in listD)

                    cenaDodatkowa += TypKursu.GetCenaDodatkowa(kursGodzina.Czas);

            }



            if (GodzinyEgzaminJazda != null)

            {

                List<KursGodzina> listEJ = GodzinyEgzaminJazda.FindAll(o => o.Czas < DateTime.Now && o.Aktywna);

                //cenaEgzaminJazda = (Double)(listEJ.Count * TypKursu.GetCenaEgzaminJazda());

                foreach (KursGodzina kursGodzina in listEJ)

                    cenaEgzaminJazda += TypKursu.GetCenaEgzaminJazda(kursGodzina.Czas);

            }



            if (GodzinyEgzaminTeoria != null)

            {

                List<KursGodzina> listET = GodzinyEgzaminTeoria.FindAll(o => o.Czas < DateTime.Now && o.Aktywna);

                //cenaEgzaminTeoria = (Double)(listET.Count * TypKursu.GetCenaEgzaminTeoria());

                foreach (KursGodzina kursGodzina in listET)

                    cenaEgzaminTeoria += TypKursu.GetCenaEgzaminTeoria(kursGodzina.Czas);

            }



            return cenaJazda + cenaTeoria + cenaDodatkowa + cenaEgzaminTeoria + cenaEgzaminJazda;

        }



        public Double GetCurrValueOfKurs(Double cenaPoRabacie)

        {

            Double cenaJazda = 0;

            Double cenaTeoria = 0;

            Double cenaEgzaminJazda = 0;

            Double cenaEgzaminTeoria = 0;

            Double cenaDodatkowa = 0;



            if (GodzinyJazdy != null)

            {

                List<KursGodzina> listJ = GodzinyJazdy.FindAll(o => o.Czas < DateTime.Now && o.Aktywna);

                //cenaJazda = (Double)(listJ.Count * TypKursu.GetCenaJazda());

                foreach (KursGodzina kursGodzina in listJ)

                    cenaJazda += TypKursu.GetCenaJazda(kursGodzina.Czas);

            }



            if (GodzinyTeorii != null)

            {

                List<KursGodzina> listT = GodzinyTeorii.FindAll(o => o.Czas < DateTime.Now && o.Aktywna);

                //cenaTeoria = (Double)(listT.Count * TypKursu.GetCenaTeoria());

                foreach (KursGodzina kursGodzina in listT)

                    cenaTeoria += TypKursu.GetCenaTeoria(kursGodzina.Czas);

            }



            if (GodzinyDodatkowe != null)

            {

                List<KursGodzina> listD = GodzinyDodatkowe.FindAll(o => o.Czas < DateTime.Now && o.Aktywna);

                //cenaDodatkowa = (Double)(listD.Count * TypKursu.GetCenaDodatkowa());

                foreach (KursGodzina kursGodzina in listD)

                    cenaDodatkowa += TypKursu.GetCenaDodatkowa(kursGodzina.Czas);

            }



            if (GodzinyEgzaminJazda != null)

            {

                List<KursGodzina> listEJ = GodzinyEgzaminJazda.FindAll(o => o.Czas < DateTime.Now && o.Aktywna);

                //cenaEgzaminJazda = (Double)(listEJ.Count * TypKursu.GetCenaEgzaminJazda());

                foreach (KursGodzina kursGodzina in listEJ)

                    cenaEgzaminJazda += TypKursu.GetCenaEgzaminJazda(kursGodzina.Czas);

            }



            if (GodzinyEgzaminTeoria != null)

            {

                List<KursGodzina> listET = GodzinyEgzaminTeoria.FindAll(o => o.Czas < DateTime.Now && o.Aktywna);

                //cenaEgzaminTeoria = (Double)(listET.Count * TypKursu.GetCenaEgzaminTeoria());

                foreach (KursGodzina kursGodzina in listET)

                    cenaEgzaminTeoria += TypKursu.GetCenaEgzaminTeoria(kursGodzina.Czas);

            }



            return Math.Min(cenaJazda + cenaTeoria, cenaPoRabacie) + cenaDodatkowa + cenaEgzaminTeoria + cenaEgzaminJazda;

        }



        public Double CenaZDodatkami

        {

            get

            {

                Double cenaEgzaminJazda = 0;

                Double cenaEgzaminTeoria = 0;

                Double cenaDodatkowa = 0;



                if (GodzinyDodatkowe != null)

                {

                    List<KursGodzina> listD = GodzinyDodatkowe.FindAll(o => o.Czas < DateTime.Now && o.Aktywna);

                    //cenaDodatkowa = (Double)(listD.Count * TypKursu.GetCenaDodatkowa());

                    foreach (KursGodzina kursGodzina in listD)

                        cenaDodatkowa += TypKursu.GetCenaDodatkowa(kursGodzina.Czas);

                }



                if (GodzinyEgzaminJazda != null)

                {

                    List<KursGodzina> listEJ = GodzinyEgzaminJazda.FindAll(o => o.Czas < DateTime.Now && o.Aktywna);

                    //cenaEgzaminJazda = (Double)(listEJ.Count * TypKursu.GetCenaEgzaminJazda());

                    foreach (KursGodzina kursGodzina in listEJ)

                        cenaEgzaminJazda += TypKursu.GetCenaEgzaminJazda(kursGodzina.Czas);

                }



                if (GodzinyEgzaminTeoria != null)

                {

                    List<KursGodzina> listET = GodzinyEgzaminTeoria.FindAll(o => o.Czas < DateTime.Now && o.Aktywna);

                    //cenaEgzaminTeoria = (Double)(listET.Count * TypKursu.GetCenaEgzaminTeoria());

                    foreach (KursGodzina kursGodzina in listET)

                        cenaEgzaminTeoria += TypKursu.GetCenaEgzaminTeoria(kursGodzina.Czas);

                }



                return Cena + cenaDodatkowa + cenaEgzaminTeoria + cenaEgzaminJazda;

            }

        }



        /// <summary>

        /// Function returns info if value of hours which shall be before sepcified godzina exceed sum of payments

        /// </summary>

        /// <param name="godzinaTyp"></param>

        /// <param name="number"></param>

        /// <returns></returns>

        public bool IsNadgodzina(GodzinaTyp godzinaTyp, int number)

        {

            Double value = 0;

            

            if (godzinaTyp == GodzinaTyp.TEORIA)

            {

                //value = (Double)(number * TypKursu.GetCenaTeoria());

                List<KursGodzina> listT = GodzinyTeorii.FindAll(o => o.Aktywna);

                for (int i = 0; i < listT.Count && i < number; i++)

                    value += TypKursu.GetCenaTeoria(listT[i].Czas);



                value = Math.Min(Cena, value);

            }



            else if (godzinaTyp == GodzinaTyp.JAZDA)

            {

                List<KursGodzina> listT = GodzinyTeorii.FindAll(o => o.Aktywna);

                foreach (KursGodzina kursGodzina in listT)

                    value += TypKursu.GetCenaTeoria(kursGodzina.Czas);



                //value += (Double)(number * TypKursu.GetCenaJazda());

                List<KursGodzina> listJ = GodzinyJazdy.FindAll(o => o.Aktywna);

                for (int i = 0; i < listJ.Count && i < number; i++)

                    value += TypKursu.GetCenaJazda(listJ[i].Czas);



                value = Math.Min(Cena, value);

            }



            else if (godzinaTyp == GodzinaTyp.DODATKOWA)

            {

                List<KursGodzina> listT = GodzinyTeorii.FindAll(o => o.Aktywna);

                foreach (KursGodzina kursGodzina in listT)

                    value += TypKursu.GetCenaTeoria(kursGodzina.Czas);



                List<KursGodzina> listJ = GodzinyJazdy.FindAll(o =>o.Aktywna);

                foreach (KursGodzina kursGodzina in listJ)

                    value += TypKursu.GetCenaJazda(kursGodzina.Czas);



                value = Math.Min(Cena, value);



                List<KursGodzina> listD = GodzinyDodatkowe.FindAll(o => o.Aktywna);

                for (int i = 0; i < listD.Count && i < number; i++)

                    value += TypKursu.GetCenaDodatkowa(listD[i].Czas);

            }



            else if (godzinaTyp == GodzinaTyp.ETEORIA)

            {

                List<KursGodzina> listT = GodzinyTeorii.FindAll(o => o.Aktywna);

                foreach (KursGodzina kursGodzina in listT)

                    value += TypKursu.GetCenaTeoria(kursGodzina.Czas);



                List<KursGodzina> listJ = GodzinyJazdy.FindAll(o => o.Aktywna);

                foreach (KursGodzina kursGodzina in listJ)

                    value += TypKursu.GetCenaJazda(kursGodzina.Czas);



                value = Math.Min(Cena, value);



                List<KursGodzina> listD = GodzinyDodatkowe.FindAll(o => o.Aktywna);

                foreach (KursGodzina kursGodzina in listD)

                    value += TypKursu.GetCenaDodatkowa(kursGodzina.Czas);



                List<KursGodzina> listET = GodzinyEgzaminTeoria.FindAll(o => o.Aktywna);

                for (int i = 0; i < listET.Count && i < number; i++)

                    value += TypKursu.GetCenaEgzaminTeoria(listET[i].Czas);

            }

            else if (godzinaTyp == GodzinaTyp.EJAZDA)

            {

                List<KursGodzina> listT = GodzinyTeorii.FindAll(o => o.Aktywna);

                foreach (KursGodzina kursGodzina in listT)

                    value += TypKursu.GetCenaTeoria(kursGodzina.Czas);



                List<KursGodzina> listJ = GodzinyJazdy.FindAll(o => o.Aktywna);

                foreach (KursGodzina kursGodzina in listJ)

                    value += TypKursu.GetCenaJazda(kursGodzina.Czas);



                value = Math.Min(Cena, value);



                List<KursGodzina> listD = GodzinyDodatkowe.FindAll(o => o.Aktywna);

                foreach (KursGodzina kursGodzina in listD)

                    value += TypKursu.GetCenaDodatkowa(kursGodzina.Czas);



                List<KursGodzina> listET = GodzinyEgzaminTeoria.FindAll(o => o.Aktywna);

                foreach (KursGodzina kursGodzina in listET)

                    value += TypKursu.GetCenaEgzaminTeoria(kursGodzina.Czas);



                List<KursGodzina> listEJ = GodzinyEgzaminJazda.FindAll(o => o.Aktywna);

                for (int i = 0; i < listEJ.Count && i < number; i++)

                    value += TypKursu.GetCenaEgzaminJazda(listEJ[i].Czas);

            }



            return (SumaRat) - value  < 0;

        }



        public bool IsFirstGodzina(GodzinaTyp godzinaTyp, long godzinaId)

        {

            bool ret = false;

            KursGodzina firstGodzina = GetFirstKursGodzinaForTypGodziny(godzinaTyp);



            if (firstGodzina != null && firstGodzina.Id == godzinaId)

                ret = true;



            return ret;

        }



        public bool IsTypGodzinyCompleted(GodzinaTyp godzinaTyp)

        {

            if (godzinaTyp == GodzinaTyp.TEORIA)

            {

                return TypKursu.GetNoHTeoria(DateTime.Now) >= 0 && !(GodzinyTeorii.FindAll(o => o.Aktywna).Count < TypKursu.GetNoHTeoria(DateTime.Now));

            }

            else if (godzinaTyp == GodzinaTyp.JAZDA)

            {

                return TypKursu.GetNoHJazda(DateTime.Now) >= 0 && !(GodzinyJazdy.FindAll(o => o.Aktywna).Count < TypKursu.GetNoHJazda(DateTime.Now));

            }

            else if (godzinaTyp == GodzinaTyp.DODATKOWA)

            {

                return TypKursu.GetNoHDodatkowa(DateTime.Now) >= 0 && !(GodzinyDodatkowe.FindAll(o => o.Aktywna).Count < TypKursu.GetNoHDodatkowa(DateTime.Now));

            }

            else if (godzinaTyp == GodzinaTyp.EJAZDA)

            {

                return TypKursu.GetNoHEgJazda(DateTime.Now) >= 0 && !(GodzinyEgzaminJazda.FindAll(o => o.Aktywna).Count < TypKursu.GetNoHEgJazda(DateTime.Now));

            }

            else if (godzinaTyp == GodzinaTyp.ETEORIA)

            {

                return TypKursu.GetNoHEgTeoria(DateTime.Now) >= 0 && !(GodzinyEgzaminTeoria.FindAll(o => o.Aktywna).Count < TypKursu.GetNoHEgTeoria(DateTime.Now));

            }

                

            return false;

        }



        public KursGodzina GetFirstKursGodzinaForTypGodziny(GodzinaTyp godzinaTyp)

        {

            KursGodzina dt = null;

            if (godzinaTyp == GodzinaTyp.TEORIA && GodzinyTeorii != null)

            {

                DateTime tmpDT = DateTime.MaxValue;

                foreach (KursGodzina kursGodzina in GodzinyTeorii.FindAll(o => o.Aktywna))

                {

                    if (tmpDT > kursGodzina.Czas)

                    {

                        tmpDT = kursGodzina.Czas;

                        dt = kursGodzina;

                    }

                }



            }

            else if (godzinaTyp == GodzinaTyp.JAZDA)

            {

                DateTime tmpDT = DateTime.MaxValue;

                foreach (KursGodzina kursGodzina in GodzinyJazdy.FindAll(o => o.Aktywna))

                {

                    if (tmpDT > kursGodzina.Czas)

                    {

                        tmpDT = kursGodzina.Czas;

                        dt = kursGodzina;

                    }

                }



            }

            else if (godzinaTyp == GodzinaTyp.DODATKOWA)

            {

                DateTime tmpDT = DateTime.MaxValue;

                foreach (KursGodzina kursGodzina in GodzinyDodatkowe.FindAll(o => o.Aktywna))

                {

                    if (tmpDT > kursGodzina.Czas)

                    {

                        tmpDT = kursGodzina.Czas;

                        dt = kursGodzina;

                    }

                }



            }

            else if (godzinaTyp == GodzinaTyp.EJAZDA)

            {

                DateTime tmpDT = DateTime.MaxValue;

                foreach (KursGodzina kursGodzina in GodzinyEgzaminJazda.FindAll(o => o.Aktywna))

                {

                    if (tmpDT > kursGodzina.Czas)

                    {

                        tmpDT = kursGodzina.Czas;

                        dt = kursGodzina;

                    }

                }



            }

            else if (godzinaTyp == GodzinaTyp.ETEORIA)

            {

                DateTime tmpDT = DateTime.MaxValue;

                foreach (KursGodzina kursGodzina in GodzinyEgzaminTeoria.FindAll(o => o.Aktywna))

                {

                    if (tmpDT > kursGodzina.Czas)

                    {

                        tmpDT = kursGodzina.Czas;

                        dt = kursGodzina;

                    }

                }

            }



            return dt;

        }



        public KursGodzina GetLastKursGodzinaForTypGodziny(GodzinaTyp godzinaTyp)

        {

            KursGodzina dt = null;

            if (godzinaTyp == GodzinaTyp.TEORIA && GodzinyTeorii != null)

            {

                DateTime tmpDT = DateTime.MinValue;

                foreach (KursGodzina kursGodzina in GodzinyTeorii.FindAll(o => o.Aktywna))

                {

                    if (tmpDT < kursGodzina.Czas)

                    {

                        tmpDT = kursGodzina.Czas;

                        dt = kursGodzina;

                    }

                }



            }

            else if (godzinaTyp == GodzinaTyp.JAZDA)

            {

                DateTime tmpDT = DateTime.MinValue;

                foreach (KursGodzina kursGodzina in GodzinyJazdy.FindAll(o => o.Aktywna))

                {

                    if (tmpDT < kursGodzina.Czas)

                    {

                        tmpDT = kursGodzina.Czas;

                        dt = kursGodzina;

                    }

                }



            }

            else if (godzinaTyp == GodzinaTyp.DODATKOWA)

            {

                DateTime tmpDT = DateTime.MinValue;

                foreach (KursGodzina kursGodzina in GodzinyDodatkowe.FindAll(o => o.Aktywna))

                {

                    if (tmpDT < kursGodzina.Czas)

                    {

                        tmpDT = kursGodzina.Czas;

                        dt = kursGodzina;

                    }

                }



            }

            else if (godzinaTyp == GodzinaTyp.EJAZDA)

            {

                DateTime tmpDT = DateTime.MinValue;

                foreach (KursGodzina kursGodzina in GodzinyEgzaminJazda.FindAll(o => o.Aktywna))

                {

                    if (tmpDT < kursGodzina.Czas)

                    {

                        tmpDT = kursGodzina.Czas;

                        dt = kursGodzina;

                    }

                }



            }

            else if (godzinaTyp == GodzinaTyp.ETEORIA)

            {

                DateTime tmpDT = DateTime.MinValue;

                foreach (KursGodzina kursGodzina in GodzinyEgzaminTeoria.FindAll(o => o.Aktywna))

                {

                    if (tmpDT < kursGodzina.Czas)

                    {

                        tmpDT = kursGodzina.Czas;

                        dt = kursGodzina;

                    }

                }

            }



            return dt;

        }



        public DateTime? GetMinDateTimeForTypGodziny(GodzinaTyp godzinaTyp)

        {

            DateTime? dt = null;

            if (godzinaTyp == GodzinaTyp.TEORIA && GodzinyTeorii != null)

            {

                DateTime tmpDT = DateTime.MaxValue;

                foreach (KursGodzina kursGodzina in GodzinyTeorii.FindAll(o => o.Aktywna))

                {

                    if (tmpDT > kursGodzina.Czas)

                        tmpDT = kursGodzina.Czas;

                }



                if(tmpDT < DateTime.MaxValue)

                    dt = tmpDT;

            }

            else if (godzinaTyp == GodzinaTyp.JAZDA)

            {

                DateTime tmpDT = DateTime.MaxValue;

                foreach (KursGodzina kursGodzina in GodzinyJazdy.FindAll(o => o.Aktywna))

                {

                    if (tmpDT > kursGodzina.Czas)

                        tmpDT = kursGodzina.Czas;

                }



                if (tmpDT < DateTime.MaxValue)

                    dt = tmpDT;

            }

            else if (godzinaTyp == GodzinaTyp.DODATKOWA)

            {

                DateTime tmpDT = DateTime.MaxValue;

                foreach (KursGodzina kursGodzina in GodzinyDodatkowe.FindAll(o => o.Aktywna))

                {

                    if (tmpDT > kursGodzina.Czas)

                        tmpDT = kursGodzina.Czas;

                }



                if (tmpDT < DateTime.MaxValue)

                    dt = tmpDT;

            }

            else if (godzinaTyp == GodzinaTyp.EJAZDA)

            {

                DateTime tmpDT = DateTime.MaxValue;

                foreach (KursGodzina kursGodzina in GodzinyEgzaminJazda.FindAll(o => o.Aktywna))

                {

                    if (tmpDT > kursGodzina.Czas)

                        tmpDT = kursGodzina.Czas;

                }



                if (tmpDT < DateTime.MaxValue)

                    dt = tmpDT;

            }

            else if (godzinaTyp == GodzinaTyp.ETEORIA)

            {

                DateTime tmpDT = DateTime.MaxValue;

                foreach (KursGodzina kursGodzina in GodzinyEgzaminTeoria.FindAll(o => o.Aktywna))

                {

                    if (tmpDT > kursGodzina.Czas)

                        tmpDT = kursGodzina.Czas;

                }



                if (tmpDT < DateTime.MaxValue)

                    dt = tmpDT;

            }



            return dt;

        }



        public DateTime? GetMaxDateTimeForTypGodziny(GodzinaTyp godzinaTyp)

        {

            DateTime? dt = null;

            if (godzinaTyp == GodzinaTyp.TEORIA && GodzinyTeorii != null)

            {

                DateTime tmpDT = DateTime.MinValue;

                foreach (KursGodzina kursGodzina in GodzinyTeorii.FindAll(o => o.Aktywna))

                {

                    if (tmpDT < kursGodzina.Czas)

                        tmpDT = kursGodzina.Czas;

                }



                if (tmpDT > DateTime.MinValue)

                    dt = tmpDT;

            }

            else if (godzinaTyp == GodzinaTyp.JAZDA)

            {

                DateTime tmpDT = DateTime.MinValue;

                foreach (KursGodzina kursGodzina in GodzinyJazdy.FindAll(o => o.Aktywna))

                {

                    if (tmpDT < kursGodzina.Czas)

                        tmpDT = kursGodzina.Czas;

                }



                if (tmpDT > DateTime.MinValue)

                    dt = tmpDT;

            }

            else if (godzinaTyp == GodzinaTyp.DODATKOWA)

            {

                DateTime tmpDT = DateTime.MinValue;

                foreach (KursGodzina kursGodzina in GodzinyDodatkowe.FindAll(o => o.Aktywna))

                {

                    if (tmpDT < kursGodzina.Czas)

                        tmpDT = kursGodzina.Czas;

                }



                if (tmpDT > DateTime.MinValue)

                    dt = tmpDT;

            }

            else if (godzinaTyp == GodzinaTyp.EJAZDA)

            {

                DateTime tmpDT = DateTime.MinValue;

                foreach (KursGodzina kursGodzina in GodzinyEgzaminJazda.FindAll(o => o.Aktywna))

                {

                    if (tmpDT < kursGodzina.Czas)

                        tmpDT = kursGodzina.Czas;

                }



                if (tmpDT > DateTime.MinValue)

                    dt = tmpDT;

            }

            else if (godzinaTyp == GodzinaTyp.ETEORIA)

            {

                DateTime tmpDT = DateTime.MinValue;

                foreach (KursGodzina kursGodzina in GodzinyEgzaminTeoria.FindAll(o => o.Aktywna))

                {

                    if (tmpDT < kursGodzina.Czas)

                        tmpDT = kursGodzina.Czas;

                }



                if (tmpDT > DateTime.MinValue)

                    dt = tmpDT;

            }



            return dt;

        }



        public DateTime GetStartDateTime()

        {

            DateTime dt = DateTime.MaxValue;



            if (this.TypKursu.GetNoHTeoria(DateTime.Now) == 0)

            {

                foreach (KursGodzina kg in GodzinyJazdy)

                {

                    if (kg.Czas.CompareTo(dt) < 0 && kg.Aktywna)

                        dt = kg.Czas;

                }

            }

            else

            {

                foreach (KursGodzina kg in GodzinyTeorii)

                {

                    if (kg.Czas.CompareTo(dt) < 0 && kg.Aktywna)

                        dt = kg.Czas;

                }

            }



            return dt;

        }



        public DateTime GetEndDateTime()

        {

            DateTime dt = DateTime.MinValue;

            

            foreach (KursGodzina kg in GodzinyEgzaminJazda)

            {

                if (kg.Czas.CompareTo(dt) > 0 && kg.Aktywna)

                    dt = kg.Czas;

            }



            return dt;

        }



        public DateTime GetEgzWewnDateTime(bool isEgzaminJazda)

        {

            DateTime dt = DateTime.MinValue;

            List<KursGodzina> lista = null;



            if (isEgzaminJazda)

                lista = GodzinyEgzaminJazda;

            else

                lista = GodzinyEgzaminTeoria;



            foreach (KursGodzina kg in lista)

            {

                if (kg.Czas.CompareTo(dt) > 0 && kg.Aktywna)

                    dt = kg.Czas;

            }



            return dt;

        }



        public long GetEgzWewnMiejsceId(bool isEgzaminJazda)

        {

            DateTime dt = DateTime.MinValue;

            long miejsceId = -1;



            List<KursGodzina> lista = null;

            if (isEgzaminJazda)

                lista = GodzinyEgzaminJazda;

            else

                lista = GodzinyEgzaminTeoria;



            foreach (KursGodzina kg in lista)

            {

                if (kg.Czas.CompareTo(dt) > 0 && kg.Aktywna)

                {

                    dt = kg.Czas;

                    miejsceId = kg.MiejsceId;

                }

            }



            return miejsceId;

        }

    

    }





}