// 2016 - СПРАВКА о среднем заработке для определения размера пособия по безработице (стипендии)
// рекомендованна: МИНИСТЕРСТВО ТРУДА И СОЦИАЛЬНОЙ ЗАЩИТЫ РОССИЙСКОЙ ФЕДЕРАЦИИ ПИСЬМО 
//                               от 15 августа 2016 г. N 16-5/В-421

int SumN   = 0; // Как выбирать суммы: 0 - начисления, 1 - принадлежности
int rasRV  = 0; // Как определять РВ: 0 - по табелю, 1 - по видам, 2 - часы по видам, дни по табелю, 4 -дни по видам, часы по табелю
int VerFormDefault = 0;
int VerForm = VerFormDefault; // В какой редакции печатать форму: 0 - в редакции 2019 года; 1 - в редакции 2016 года
bool GetDniFromTabel   = false;//вне зависимости от значения настройки rasRV - "Дни" всегда берем из табеля
bool GetHoursFromTabel = false;//вне зависимости от значения настройки rasRV - "Часы" всегда берем из табеля
int hc_sn = 0;        //как расчитывать среднее
bool roundDN = false; //округлять дни до целого
bool round_H = false; //округлять часы до целого
bool koeff_stavki       = false;//применять коэф. ставки к НРВ?
bool koeff_stavki_day   = false;//применять коэф. ставки к дням
bool koeff_stavki_hours = false;//применять коэф. ставки к дням

int AccDefault = 2; //точность по умолчанию
int AccRv      = AccDefault; //точность(количество знаков после запятой) для РВ
bool takeLastMonth = true; //берем последний месяц( увольнения) в расчет среднего (иначе сдвигаем период для расчета среднего)
int dn_ned_all =7;
bool SimpleCalcCalendWeeks = true; // календарные недели считаются без всяких пропорций, то есть обычные календарные недели
string sRow; // буквенное обозначение адреса (или адрес) ячейки Excel (при необходимости)

int cntItogo = 7;
double Itogo[cntItogo]; //Itogo[1] - сумма, Itogo[2]-НРВ_Днях, Itogo[3]-ФРВ_Днях, 
                        //Itogo[4] - количество искл.дней, Itogo[5] - НРВ_Часах, Itogo[6] - ФРВ_Часах

int idxTN        = 0, // 
    idxF         = 1, // 
    idxI         = 2, // 
    idxO         = 3, // 
    idxD_rb      = 4, // 
    idxD_uv      = 5, // 
    idxNumDoc    = 6, // 
    idxDolg      = 7, // 
    idxDDolg     = 8, // 
    idxMBeg      = 9, // 
    idxMEnd      = 10, // 
    idxSumPer    = 11, // 
    idxSumMes    = 12, // 
    idxDateDoc   = 13, //

    nFld = 14;  // число элементов в массиве Fld

int    Fld[nFld];
 
Srz_sprav_16(array_param)
{
   var CurFile = CreateObject("CurPrnFile");
   CurFile.SetFlagBrowse(0);
   CurFile.SetFlag_Print(0);

   var CTabl  = CreateObject("CurPrnTbl");
   int cntRcr = CTabl.Count_Rcr(); // полное число записей   

   //=========================
   // Настройки формы
   //=========================
   rasRV  = GetCommonCnfInt("RasRV" ,"SprSlZan"); // 0 - по табелю, 1 - по видам
   if (rasRV) { GetDniFromTabel = rasRV & 0x02; GetHoursFromTabel = rasRV & 0x04; }
         else { GetDniFromTabel = true; GetHoursFromTabel = true; }

   SumN   = GetCommonCnfInt("SumN"  ,"SprSlZan"); // 0 - начисления, 1 - принадлежности
   hc_sn  = GetCommonCnfInt("hc_sn" ,"SprSlZan"); // как расчитывать среднее

   if ( IsCommonCnfExist("roundRV","SprSlZan") )
   {
      char Buf[81];
      GetCommonCnf("roundRV","SprSlZan",Buf,80);  
      int roundRV=atoi(Buf);
      
      roundDN=roundRV & 0x01; //округлять дни
      round_H=roundRV & 0x02; //округлять часы
   }
   if ( IsCommonCnfExist("dol9","SprSlZan") )
   {
      char Buf[81];
      GetCommonCnf("dol9","SprSlZan",Buf,80);  
      int Flag=atoi(Buf);
      koeff_stavki_day   = Flag & 0x01;  //применяем ставку к норма дням
      koeff_stavki_hours = Flag & 0x02;  //применяем ставку к норма часам
      if (koeff_stavki_day || koeff_stavki_hours) koeff_stavki=true;
   }
   if ( IsCommonCnfExist("accRv","SprSlZan") )
   {
      char Buf[81];
      GetCommonCnf("accRv","SprSlZan",Buf,80);  
      AccRv=atoi(Buf);
      if ( AccRv>5 || AccRv<0 )  AccRv=AccDefault;
   }
   if ( IsCommonCnfExist("VerForm","SprSlZan") )
   {
      char Buf[81];
      GetCommonCnf("VerForm","SprSlZan",Buf,80);  
      VerForm = atoi(Buf);
      if ( VerForm > 1 || VerForm < 0 ) VerForm = VerFormDefault;
   }

   string sim_r[4], sim_n[4];
   int CntPrm = atoi(array_param[0]); 
   sim_r[0] = to_string(array_param[1]);
   sim_r[1] = to_string(array_param[2]);     
   sim_n[0] = to_string(array_param[3]);

   //=========================
   
   char Org[256], code[256], str[256], arg[256], nnn[256], sss[256], buf[256], cell[256];

   string s_tn ="", s_f="";
   var RazbW = CreateObject("ParamFuncRW");
   var Razb  = CreateObject("ParamFuncRW");

   var CMsg = 0;    // Процент выполненной работы
   int bTime = false;   // false-показывать процент,
                        // true-показывать оставшееся время

   CMsg=CreateObject("ProgressBar");
   CMsg.Initial(0,100,1);
   CMsg.SetShowTime(static_cast_to_int(bTime));

   if ( !FillNumFld(CTabl) ) return false; //определяем необходимые нам номера полей

   string m1 = "01."+to_string(CTabl.Text(Fld[idxMBeg],0));
   string m2 = "01."+to_string(CTabl.Text(Fld[idxMEnd],0));
   FreeSpaceString(m1,2," ");FreeSpaceString(m2,2," ");

   var BegMonPer=CreateObject("KMonth"); // месяц начала периода   
   var EndMonPer=CreateObject("KMonth"); // месяц конца периода   
   BegMonPer.SetDate(to_string(m1));   
   EndMonPer.SetDate(to_string(m2)); 
   
   int CntMonth = EndMonPer.Diff(BegMonPer)+1;
   if( CntMonth!=12 )
   {
      str = "Средний заработок работника должен исчисляться за последние 12 календарных месяцев, предшествующих месяцу увольнения. Продолжить?";
      if ( AmbaMessageBox(str,"Предупреждение!",MB_YESNO,0) != IDYES )
         return false;
   }

   try
   {
      string NameXlt = GetPathXLT(NameCommonDir(),VerForm ? "srz_16.xlt" : "srz_19.xlt"); // путь к шаблону 
    
      tPrepereOfficeForWork(); // определяем работать на Excel или на Calc (определяем какой из офисов (MS Office или OpenOffice) установлен и какой предпочтительнее)
      tCreateXlsObjects(to_string(NameXlt),"Справка о среднем заработке"); //создание основных объектов

      int n_wsh = 1;
      tGetWshByIndex(1); // получаем ссылку на лист (worksheet)
      tWshSelect();
      //tMakeXlsVisible(); // для отладки

      // Дата формирования справки
      char StrDat2[30]; StrDat2=CTabl.Text(Fld[idxDateDoc],0);
      R_DATA_PROPIS(StrDat2,StrDat2,20,0);
      FreeSpaceString(StrDat2,2," "); StrDat2 += " г."; 
      if ( VerForm ) sRow = "A59"; else sRow = "A45";
      tWriteStringToCell(sRow,PrepareStr(StrDat2));  

      // Адрес организации
      GetEnterpriseVar("АДРП",str,255); FreeSpaceString(str,2," ");
      // Сначало удалим лишние запятые в адресе 
      var RazbAdr = CreateObject("ParamFuncRW");
      RazbAdr.IInitial(to_string(str),",",20);
      if ( RazbAdr.Count() )
      {  
         str = RazbAdr.Get(0);
         for ( int ii=1; ii<RazbAdr.Count(); ii++ )
            str += ", "+RazbAdr.Get(ii);
      }
      RazbW.IInitialW(to_string(str),50,255," ,.;'\"");
      tWriteStringToCell("A4",PrepareStr(RazbW.Get(0)));
      tWriteStringToCell("A5",PrepareStr(RazbW.Get(1)));

      // ИНН  
      GetEnterpriseVar("ИНН",str,255); tWriteStringToCell("BT1",PrepareStr(str)); 
      // ОКВЭД  
      GetEnterpriseVar("ОКВЭД",str,255); tWriteStringToCell("BT3",PrepareStr(str)); 
      // Наименование организации
      GetEnterpriseVar("ИМЯП",str,255); tWriteStringToCell("A15",PrepareStr(str));
      // Руководитель
      GetEnterpriseVar("РУКП",str,255);
      if ( VerForm ) sRow = "AW52"; else sRow = "AW38"; tWriteStringToCell(sRow,PrepareStr(str));
      // Главный бухгалтер
      GetEnterpriseVar("ГЛБУХ",str,255);
      if ( VerForm ) sRow = "AW54"; else sRow = "AW40"; tWriteStringToCell(sRow,PrepareStr(str));
      // Телефон
      GetEnterpriseVar("ТЕЛП" ,str,255);
      if ( VerForm ) sRow = "CE59"; else sRow = "CE45"; tWriteStringToCell(sRow,PrepareStr(str));
 
      // цикл по записям таблицы
      for (int zap=0; zap<cntRcr; zap++)
      {
         for(int i=0;i<cntItogo;i++) Itogo[i]=0.;

         // progress bar - чтобы видеть процент выполненной работы до того как появится результат
         if ( CMsg.Msg_Proc(" Подождите немного. Идет подготовка к печати. ",100.*zap/cntRcr)==ESC )
         {    return 0;   }

         // TH
         int TN = atoi(CTabl.Text(Fld[idxTN],zap));

         // название листа = фамилия + tn    
         s_tn = to_string(TN);
         s_f  = to_string(CTabl.Text(Fld[idxF],zap));
         FreeSpaceString(s_tn,3,"");FreeSpaceString(s_f,3,"");

         tCopyWshByIndex(n_wsh,s_f+" "+s_tn);
         tGetWshByIndex(n_wsh); n_wsh++; // увеличиваем счетчик листов
         tWshSelect();

         // ФИО
         str = CTabl.Text(Fld[idxF],zap)+" "+CTabl.Text(Fld[idxI],zap)+" "+
                      CTabl.Text(Fld[idxO],zap);
         // Просклоняем фамилию имя отчество
         GetFIOPadegFSAS(str,3,str,40);
         tWriteStringToCell("L12",PrepareStr(str));

         // Дата поступления на работу
         str = CTabl.Text(Fld[idxD_rb],zap);
         if ( Str_Cmp(str,""," .,;/-") ) { R_DATA_PROPIS(str,str,20,0); str += " г."; }
         tWriteStringToCell("BJ14",PrepareStr(str));
         // Дата увольнения
         str = CTabl.Text(Fld[idxD_uv],zap);
         if ( IsCommonCnfExist("takeMUv","SprSlZan") )
         {
            var DatUv = CreateObject("KDate");
            DatUv.SetDate(to_string(str)); 
            GetCommonCnf("takeMUv","SprSlZan",buf,80);  
            if(!atoi(buf) && DatUv.GetAbs()==EndMonPer.GetAbs()) takeLastMonth=false;
                                                            else takeLastMonth=true;
         } 
         if (Str_Cmp(str,""," .,;/-") ) { R_DATA_PROPIS(str,str,20,0); str += " г."; }
                                   else str = "настоящее время";
         tWriteStringToCell("CF14",PrepareStr(str));

         // Основание выдачи
         string osn = "Справка выдана на основании лицевого счета № " + s_tn;
         //cell="A"+to_string(50+cntInserRow);
         if ( VerForm ) sRow = "A50"; else sRow = "A36"; tWriteStringToCell(sRow,PrepareStr(osn));
     
         // чтение ЛС
         char ls[255]; // буфер для имени ЛС   
         lsname(Find_Full_TN(TN),ls);
         if ( 1 != lsread(ls,0))  
         {
            AmbaMessageBox("Невозможно прочитать ЛС!","Ошибка!",0,0);
            return 0; 
         } 
         //=========================
         //2018.06.15 ограничиваем даты периодов датой приема и датой увольнения (todo: по-хорошему - надо пробежаться по всем исп. должностям...)
         var dpr=KDateFromStr(kch_from_safe("data_rb"));
         var duv=KDateFromStr(kch_from_safe("data_uv"));
         var db=KDateFromStr(BegMonPer.GetStr());
         var de=KDateFromStr(EndMonPer.GetStr());de.ShiftMonth(1); de.Dec();
         if (dpr.IsValid() && dpr.GT(db))
          db.SetDateD(dpr.GetDouble());
         if (duv.IsValid() && duv.LT(de))
          de.SetDateD(duv.GetDouble());

         //=========================
         int  pBeg = db.GetAbs(), pEnd   = de.GetAbs(),
            pBegOt = db.GetRel(), pEndOt = de.GetRel();
         int mraschold = mrasch;
         int mesec;  

         int cntInserRow=0;  //количество добавленных строк
         int row=43;         //номер "текущей" строки excel

         string mesn = "";
         double spm = 0.0, Itogo_frv_d = 0;
         double it2 = 0, it4 = 0, it5 = 0;
         int cntm = 0;

         //=========================
         // Периоды, исключаемые при подсчете среднего заработка 
         // (очередной отпуск, б/л, простой, отпуск без сохранения з/пл и т.д.)
         // Месяцы расчетного периода, год
         var MonthBeg=CreateObject("KMonth"); MonthBeg.SetMonth(pBeg);
         var MonthEnd=CreateObject("KMonth"); MonthEnd.SetMonth(pEnd);

         var mapPeriods = GetExclPeriodsForPeriod(MonthBeg,MonthEnd);
       
         //цикл по периодам
         if ( VerForm )
         {
            for ( bool Cur=mapPeriods.InitIterator(); Cur; Cur=mapPeriods.Next() )
            {
               var part = CreateObject("ParamFuncRW");
               part.IInitial1(to_string(mapPeriods.GetCurValue()),"_",20);
               int cntDay = part.Get(0);
               if(!cntDay) continue;
               string comment = part.Get(1);
               string beg = part.Get(2);
               string end = part.Get(3);
             
               //если искл.периодов больше двух - каждый последующий печатаем в новой строке
               if( row>45 ) { tInsertRows(row,2); tCopyRows(row,2); cntInserRow += 2; }
              
               // Строка кол-во (с__ по___)
               sprintf(cell,"C%d",row);  tWriteStringToCell(cell,beg); 
               sprintf(cell,"Y%d",row);  tWriteStringToCell(cell,end); 
               sprintf(cell,"AS%d",row); tWriteStringToCell(cell,OemToAnsi(comment)); //причина 
            
               Itogo[4] += cntDay;
               row += 2; 
            }
            // удаляем лишние строки
            if ( cntInserRow ) tDeleteRows(row,2);
         }

         //=========================
         // определение периодов работы на полный и не полный день 
         int row_pn    = 30, cnt_pn    = 0;
         int row_ne_pn = 33, cnt_ne_pn = 0;

         if ( !VerForm )
         {
            row_pn    = 18;
            row_ne_pn = 21;
         }

         string periods_nepoln=GetExclPeriodsNepoln(db.GetStr(),de.GetStr());//!!!
         var period_nepoln = CreateObject("ParamFuncRW");
         period_nepoln.IInitial1(to_string(periods_nepoln),";",99);

         int period = 0;

         if ( VerForm ) period = period_nepoln.Count() - 1;

         //цикл по периодам неполного рабочего времени из КЧ
         for ( int i = period; i > -1; i-- )
         {
            var part = CreateObject("ParamFuncRW");
            part.IInitial1(to_string(period_nepoln.Get(i)),"_",99);
      
            int CodR = atoi(part.Get(2));    
            string comment = part.Get(2);
            string beg = part.Get(0);
            string end = part.Get(1);
            int    CntWDay   = atoi(part.Get(3)); // рабочие дни в неделю
            double CntWHours = atof(part.Get(4)); // количество часов в день

            if ( CodR != 2 && CodR != 8 /* внешние совместители не работают на полный день..*/ && CodR != 4 && CodR != 9 )  
            {// Полный рабочий день          
               if ( cnt_pn ) 
               { 
                  row_pn++; row_ne_pn++;  
                  tInsertRows(row_pn,1); tCopyRows(row_pn,1); 
               }

               if ( VerForm )
               {
                  sprintf(cell,"BJ%d",row_pn); tWriteStringToCell(cell,beg); 
                  sprintf(cell,"CF%d",row_pn); tWriteStringToCell(cell,end); 
               }

               // Количество дней в неделю
               if ( VerForm ) sRow = "AE"; else sRow = "BQ"; 
               sRow += to_string(row_pn);
               tWriteStringToCell(sRow,PrepareStr(CntWDay));

               if ( VerForm ) sRow = "A"; else sRow = "AM"; 
               sRow += to_string(row_pn);
               tWriteStringToCell(sRow,PrepareStr(CntWHours));

               cnt_pn++;
            }
            else
            {// Не полный рабочий день          
               if ( cnt_ne_pn ) 
               { 
                  row_ne_pn++;
                  tInsertRows(row_ne_pn,1); tCopyRows(row_ne_pn,1); 
               }

               if ( VerForm )
               {
                  sprintf(cell,"BJ%d",row_ne_pn); tWriteStringToCell(cell,beg); 
                  sprintf(cell,"CF%d",row_ne_pn); tWriteStringToCell(cell,end); 
               }

               // Количество дней в неделю
               if ( VerForm ) sRow = "AE"; else sRow = "BS";
               sRow += to_string(row_ne_pn);
               tWriteStringToCell(sRow,PrepareStr(CntWDay));

               if ( VerForm ) sRow = "A"; else sRow = "AO";
               sRow += to_string(row_ne_pn);
               tWriteStringToCell(sRow,PrepareStr(CntWHours));

               cnt_ne_pn++;
            }
         }

         //=========================
         // расчет рабочего времени 

         int shift=(takeLastMonth)?0:1;         
         //цикл по месяцам
         for (mesec=pBeg; mesec<=pEnd; ++mesec)
         { 
            s50(mesec);

            //определяем ФРВ и НРВ за месяц  mesec в днях и часах
            double frv_d=0., nrv_d=0., frv_ch=0., nrv_ch=0.;
            DefineFrvNrv(frv_d,nrv_d,frv_ch,nrv_ch);
        
            // Месяцы расчетного периода, год
            var Month=CreateObject("KMonth"); Month.SetMonth(mesec);
        
            //Заработная плата начисленная
            string Sums= CTabl.Text(Fld[idxSumMes],zap);
            var sums = CreateObject("ParamFuncRW");
            sums.IInitial1(to_string(Sums),",",99);

            int idxMonth=mesec-pBeg+1;

            if (idxMonth<sums.Count())
            { 
               Itogo[1] += atof(sums.Get(idxMonth));

               if ( ( pEnd - mesec< 3 +shift ) && (cntm<3) )// последние 3 месяца выборки
               {
                  if ( !cntm || cntm==2 ) mesn += Month.GetStr();
                                     else mesn += "-";
                  cntm++;
                  spm += atof(sums.Get(idxMonth));
                  Itogo_frv_d += frv_d;
                  it2 += nrv_d;
                  it4 += frv_ch;
                  it5 += nrv_ch;
               }
            } 

            char str_f[256];
            sprintf(str_f,"%.*f\n(%.*f)",(roundDN)?AccRv:AccDefault,frv_d,(round_H)?AccRv:AccDefault,frv_ch);     
            Itogo[3]+=frv_d; Itogo[5]+=frv_ch;
        
            //норма дней
            char str_n[256];  
            sprintf(str_n,"%.*f\n(%.*f)",(roundDN)?AccRv:AccDefault,nrv_d,(round_H)?AccRv:AccDefault,nrv_ch);    
            Itogo[2]+=nrv_d; Itogo[6]+=nrv_ch;
         }
         if ( mraschold!=mrasch ) s50(mraschold);

         double SumPer  = atof(CTabl.Text(Fld[idxSumPer],zap));
         double SrDnZar = 0; double SrSumm =0.;
     
         // Средний дневной заработок исчисляется путем деления суммы заработной платы, фактически начисленной 
         // за расчетный период, на количество фактически отработанных в этот период дней.

         // Средний заработок работника определяется путем умножения среднего дневного заработка 
         // на среднемесячное число рабочих дней в расчетном периоде (в зависимости от установленной 
         // продолжительности рабочей недели в организации).

         int Rub = 0, Kop = 0;
     
         if ( hc_sn == 0)    // Считаем по 62 постановлению пункт 7
         { 
            if ( nabs(Itogo_frv_d) > 0.00001 ) SrDnZar = spm/Itogo_frv_d;
            double SrMesDn = it2/cntm;
            SrSumm = SrDnZar*SrMesDn;
         }
         if ( hc_sn == 1)    // считаем как хочет инспектор
         {
            SrSumm = spm/3;
         }
           
         sprintf(str,"Средний заработок за последние три месяца (%s) составил",mesn);

         if ( VerForm ) sRow = "A18"; else sRow = "A26";
         tWriteStringToCell(sRow,OemToAnsi(str));

         str = GetSum(atof(SrSumm),Rub,Kop);

         if ( VerForm ) sRow = "A19"; else sRow = "A27";  tWriteStringToCell(sRow,PrepareStr(str));
         if ( VerForm ) sRow = "BP18"; else sRow = "BP26"; tWriteStringToCell(sRow,Rub);
         if ( VerForm ) sRow = "CN18"; else sRow = "CN26"; tWriteStringToCell(sRow,Kop);
         
     
         //=========================
         // Количество календарных недель
         {
         bool fl[4]; string beg[4], end[4];
         for(int i=0;i<4;i++) { fl[i] = false; beg[i]="", end[i]=""; }

         var map = CreateObject("MapString");
         map.Clear(); int CountPer = 0;
         char d1[256], d2[256];
         var kalend = Createobject("KMonth");       
         double opl_r = 0., opl_rab =0., opl_rab_ch=0., neopl=0., kalend_d=0., opl_r_fakt=0., nedelek=0.; double Hours=0.;
         for (mesec=pBeg; mesec<=pEnd; ++mesec)
         { 
            s50(mesec);
            kalend.SetMonth(mesec);
          
            // если месяц совпадает с днем приема на работу или увольнения, нужно взять не все дни месяца
            if ( mesec==dpr.GetAbs() ) kalend_d += dpr.CountDay()-dpr.GetDay()+1;         
            else if ( mesec==duv.GetAbs() ) kalend_d += duv.GetDay();         
            else kalend_d += kalend.CountDay();   // Количество дней в месяце  

            opl_r += CountDayChas(mesec,sim_r[0],"n",0,0);  // Выбираем ТОЛЬКО рабочие дни в часах
            opl_r_fakt +=CountDayChas(mesec,sim_r[0],"n",0,1); // Выбираем ТОЛЬКО рабочие дни в днях
            opl_rab += CountDayChas(mesec,sim_r[1],"n",0,1); // Выбираем периоды оплачиваемой работы в днях
            opl_rab_ch += CountDayChas(mesec, sim_r[1], "n", 0, 0); // Выбираем периоды оплачиваемой работы в часах (отпуска, больничные и т.д.)
            neopl += CountDayChas(mesec, sim_n[0], "n", 0, 0); // Выбираем периоды неоплаты в часах
             
            for ( int i=1; i<=countday ; i++ )
               for ( int j=0; j<4; j++ )
               {
                  if ( dney_v_tab(sim_n[j],calm,i,i) )
                  {
                     if ( !fl[j] )
                     {    
                        // запоминаем начало
                        beg[j] = to_string(i)+";"+
                                 to_string(mesec);
                        end[j] = to_string(i)+";"+
                                 to_string(mesec);         
                        fl[j] = true;
                     }
                     else // запоминаем конец
                     {
                        end[j] = to_string(i)+";"+
                                 to_string(mesec);
                     }
                  }
                  else if ( fl[j] )
                  {
                     sprintf(str,"%d;%s;%s",j,beg[j],end[j]);
                     map.Add(to_string(CountPer),to_string(str));
                     CountPer++; fl[j] = false;
                  }
               }
         } //for po mesec

         for ( int j=0; j<4 ;j++ ) if ( fl[j] ) //остались не завершенные периоды
         {
            sprintf(str,"%d;%s;%s",j,beg[j],end[j]);
            map.Add(to_string(CountPer),to_string(str));
            CountPer++; fl[j] = false;
         }

         if ( mraschold!=mrasch ) s50(mraschold);

         // Формула расчета (исключаемые периоды не включаем): 
         // кол-во календарных дней в расчетном периоде     кол-во фактически отработанных часов 
         // -------------------------------------------  *  --------------------------------------
         //               7                      кол-во часов подлежащих отработке 
         //                                                 по производственному календарю (норме) 

         nedelek = kalend_d/dn_ned_all;
         if ( !SimpleCalcCalendWeeks ) 
         {
            //если РВ берем из видов, то недели считаем так Itogo[3]/5 округленное до целого  
            if ( !GetDniFromTabel )
                 nedelek  = atoi(Itogo[3]/5);
            else nedelek *= (opl_r/Itogo[6]);  
         }

         if ( VerForm ) sRow = "BG27";
         else 
         {
            // ФИО
            str = CTabl.Text(Fld[idxF],zap)+" "+CTabl.Text(Fld[idxI],zap)+" "+CTabl.Text(Fld[idxO],zap);
            tWriteStringToCell("A54",PrepareStr(str));
            sRow = "AZ54";
         }

         tWriteStringToCell(sRow,to_string(atoi(nedelek)));

         }
         ///////////////////////////    
    
         // чтобы не было выделенной строки после всех манипуляций с копированием
         // выделим отдельную ячейку.
         tWshCellSelect(1,1);       
      } //for

      // чтобы не было выделенной строки после всех манипуляций с копированием
      // выделим отдельную ячейку.
      tWshCellSelect(1,1);       

      tGetWshByIndex(n_wsh); // получаем ссылку на лист (worksheet)
      tWshHide(); // делаем лист невидимым

   } //try
   //что Excel не остовался в памяти
   catch(object err)
   {
      tEndXlsWork(1); // делаем форму видимой
      SayError(err);
      return 1;
   }
   catch(...)
   {  
      SayUndefinedScriptError();
      tEndXlsWork(1); // делаем форму видимой
      return 1;
   }

   tGetWshByIndex(1);
   tWshSelect();
   tEndXlsWork(1); // делаем форму видимой
   return 0;
}



GetSum(Sum,&rub,&kop)
{
  char str[256], arg[256]; 
  int W = 14, A = 2;

  sprintf(arg,"%*.*f",W,A,atof(Sum)); // сумма прописью
  R_MAKE_SCRIPT(arg,str,100,0);

  rub = atoi(SubStr(to_string(arg),0,W-A));
  kop = atoi(SubStr(to_string(arg),W-A,A));

  return str;
}

PrepareStr(stroka)
{
  char str[256]; str = stroka; 
  FreeSpaceString(str,2,""); 
  OemToChar(str,str);
  return str;
}

FillNumFld(CTabl)
//=============================================================================
// Находим поля в таблице
//=============================================================================
{
  Fld[idxTN]      = CTabl.Find_Name_Fld("C_FIO");    
  Fld[idxF]       = CTabl.Find_Name_Fld("FCf");
  Fld[idxI]       = CTabl.Find_Name_Fld("FCi");
  Fld[idxO]       = CTabl.Find_Name_Fld("FCo");
  Fld[idxD_rb]    = CTabl.Find_Name_Fld("FCdata_rb");
  Fld[idxD_uv]    = CTabl.Find_Name_Fld("FCdata_uv");
  Fld[idxNumDoc]  = CTabl.Find_Name_Fld("NumDoc");
  Fld[idxDateDoc] = CTabl.Find_Name_Fld("DateDoc");
  Fld[idxDolg]    = CTabl.Find_Name_Fld("Dolg");
  Fld[idxDDolg]   = CTabl.Find_Name_Fld("DDolg");

  Fld[idxMBeg]    = CTabl.Find_Name_Fld("MBeg");
  Fld[idxMEnd]    = CTabl.Find_Name_Fld("MEnd");

  if ( !SumN )
  {
    Fld[idxSumPer]  = CTabl.Find_Name_Fld("SumPer");
    Fld[idxSumMes]  = CTabl.Find_Name_Fld("SumMes");
  }
  else
  {  
    Fld[idxSumPer]  = CTabl.Find_Name_Fld("SumPer2");
    Fld[idxSumMes]  = CTabl.Find_Name_Fld("SumMes2");
  }  

  for ( int ii=0; ii<nFld; ii++ )
     if ( Fld[ii]==-1 )
     {
        AmbaMessageBox("Нет необходимых полей в таблице!","Ошибка!!!",MB_OK|MB_ICONERROR,0);
        return false;
     }
  return true;
}

DefineFrvNrv(&frv_d,&nrv_d,&frv_ch,&nrv_ch)
//*********************************************************
// Функция определяет ФРВ и НРВ
//*********************************************************
{
   double n6;s98(0,n6);
  
   if( GetDniFromTabel )
   {
      frv_d= dney_v_tab(rsimv,calm,1,countday);
      nrv_d= dney_v_tab(simv_nr,calmras,1,countday);
   }
   else
   {
      nrv_d = norm(1); // - отработанных дней
      frv_d = n6*norm(1);
   }
    
   if( GetHoursFromTabel )
   {
      skoljko(frv_ch,data,1,countday,rsimv,calm,1);  
      skoljko(nrv_ch,data,1,countday,simv_nr,calmras,0);  
   }
   else
   {
      nrv_ch = norm(2); // - отработанных часов
      frv_ch = n6*norm(2); 
   } 
   //применияем ставку к НРВ
   if (koeff_stavki)
   {
      char tmp[256];
      var D = CreateObject("KDate");D.SetDateII(countday,mrasch);
      GetKchValue("k_employ",tmp,10,D);
      double koeff=1.;
      //если 0< ставка <1
      if (  atof(tmp)>0.00001 && 
            atof(tmp)<1-0.00001   ) 
         koeff=atof(tmp);

      if (koeff_stavki_day) nrv_d*=koeff;
      if (koeff_stavki_hours) nrv_ch*=koeff;
   }
   if(roundDN)
   {
      roundd(nrv_d,AccRv,nrv_d); 
      roundd(frv_d,AccRv,frv_d); 
   } 
   if(round_H)
   {
      roundd(nrv_ch,AccRv,nrv_ch); 
      roundd(frv_ch,AccRv,frv_ch); 
   }  
} 


GetExclPeriodsForPeriod(MonthBeg,MonthEnd)
//*********************************************************
// Функция находит периоды, не включенные во время 
// оплачиваемой работы
// Возвращает MapString из строк вида
// "кол-во дней_комментарий_дата начала_дата конца"
//*********************************************************
{
  var mapRez = CreateObject("MapString");
  mapRez.Clear();

  var db = CreateObject("KDate");     db.SetDateII(1,MonthBeg.GetAbs());
  var de = CreateObject("KDate");     de.SetDateII(MonthEnd.CountDay(),MonthEnd.GetAbs());

  int Holidays=0, MinusH=0, All=0, Cnt=1;
  var ExclPeriods=CalcMinusDni(db.GetStr(),de.GetStr(),"SprSlZan",de.GetStr(),Holidays,MinusH,1,0,All);
  int cntPer = ExclPeriods.Count();

  //цикл по периодам
  for ( ExclPeriods.SetBegin(); !ExclPeriods.End(); ExclPeriods.Next())
  {
    string DBeg = (cntPer>0)?ExclPeriods.GetCurBeg().GetStr():"-";
    string DEnd = (cntPer>0)?ExclPeriods.GetCurEnd().GetStr():"-";
    int cntDays = (cntPer>0)?(ExclPeriods.GetCurEnd().Diff(ExclPeriods.GetCurBeg())+1):0;
    string Comment = "-";
    try
    {
      Comment=(cntPer>0)?ExclPeriods.GetCurCod():"-";
      //для "прочие исключаемые периоды" - пытаемся определить по табелю что именно за период
      if(IsSubStrPresent("прочие исключаемые периоды",Comment) )
        Comment=TryDefinePeriod(Comment,ExclPeriods.GetCurBeg());
    }
    catch (...)
    {
      ;
    }
    char tmp[256];
    sprintf(tmp,"%d_%s_%s_%s",cntDays,Comment,DBeg,DEnd);   
    mapRez.Add(to_string(Cnt),to_string(tmp));
    Cnt++;
  }

  return mapRez;
}

TryDefinePeriod(Comment,date_beg)
{
   string rez=Comment;
   //получаем символ табеля за день, указанный в date_beg
   char sim;
   int mraschold=mrasch;
   s50(date_beg.GetAbs());
   sim=calm[date_beg.GetDay()-1];
   if ( mraschold!=mrasch ) s50(mraschold);
   switch(sim)
   {
      case 'О':rez="очередной отпуск";break;
      case 'У':rez="учебный отпуск";break;
      case 'А':rez="отпуск без сохранения з/пл";break;
      case 'В':
      case 'Е':rez="простой";break;
      case 'Н':rez="неявка";break;
   } 
   return rez;
}

GetExclPeriodsNepoln(d1,d2)
//*********************************************************
// Функция находит периоды работы на полный и неполный день
// по полям КЧ - код работы для ср.списочной и код нормативного графика
// Возвращает строку: дата начала_дата конца_код работы_кол-во дней в неделю_кол-во часов в день
//*********************************************************
{
   char nepoln[1024]; nepoln="";
   var db = CreateObject("KDate"); db.SetDate(d1); 
   var de = CreateObject("KDate"); de.SetDate(d2);  
  //     de.ShiftMonth(1); de.Dec();

   // Поехали по полю КЧ (код работы для ср.списочной)
   // Дата конца действия очередного значения кода работы
   // В самом начале она равна дате окончания периода [_d1,_d2]
   var DateEnd = CreateObject("KDate");
   DateEnd.SetDate(de.GetStr());
   
   // Найдем дату начала действия очередного значения кода работы
   char StrD[21],StrD_G[21];
   GetKchDate("kod_rab",StrD,10,DateEnd);
   GetKchDate("grafik",StrD_G,10,DateEnd);
   
   var Date = CreateObject("KDate");
   Date.SetDate(to_string(StrD));
   var DateGr = CreateObject("KDate");
   DateGr.SetDate(to_string(StrD_G));
   // Если график работы поменялся, запомним его дату начала
   if ( Date.IsEqI(INVALID_DATE_VALUE) || Date.LT(DateGr) ) Date.SetDate(to_string(StrD_G));
   
   var DateBPer=CreateObject("KDate");
   DateBPer.SetDateII(db.GetDay(),db.GetAbs());
   
   var DateEPer=CreateObject("KDate");
   DateEPer.SetDateII(de.CountDay(),de.GetAbs());

   // Если вдруг дата начала пустая или выходит за рамки нашего периода
   // то установим ее равной началу периода
   if ( Date.IsEqI(INVALID_DATE_VALUE) || Date.LT(DateBPer) )
      Date.SetDate(DateBPer.GetStr());
   
   // Ну и просматриваем все значения кода работы, действовавшие в
   // рассматриваемом периоде
   char StrKodRab[21],StrKodRabE[21],KodRab_periodE[256];
   char StrNGrafik[21],StrNGrafikE[21];

   int KodRabE  = atoi(GetKchValue("kod_rab",StrKodRabE,20,DateEnd));
   int NGrafikE = atoi(GetKchValue("grafik",StrNGrafikE,20,DateEnd));
   if ( !NGrafikE ) NGrafikE = 1;

   int CntWDay = GetCountWeekDays(NGrafikE);
   double CntWHours = (GetCountWeekHours(NGrafikE)/CntWDay);
   if ( round_H ) roundd(CntWHours,AccRv,CntWHours); 

   sprintf(KodRab_periodE,"%s_%s_%s_%d_%f",Date.GetStr(),DateEnd.GetStr(),StrKodRabE,CntWDay,CntWHours);
   nepoln+=KodRab_periodE+";";

   while ( 1 )
   {
      // Устанавливаем дату конца очередного значения кода работы
      // равной дате начала уже рассмотренного значения минус один день.
      DateEnd.SetDateD(Date.GetDouble());
      DateEnd.Dec();

      // Если дата конца вышла за пределы рассматриваемого периода - выходим
      if ( DateEnd.IsEqI(INVALID_DATE_VALUE) || DateEnd.LT(DateBPer) )
        break;

      // Находим дату начала для очередного значения кода работы и нормативного графика
      GetKchDate("kod_rab",StrD,10,DateEnd);
      GetKchDate("grafik" ,StrD_G,10,DateEnd);

      Date.SetDate(to_string(StrD));
      DateGr.SetDate(to_string(StrD_G));

      // Если график работы поменялся, запомним его дату начала
      if ( Date.IsEqI(INVALID_DATE_VALUE) || Date.LT(DateGr) ) Date.SetDate(to_string(StrD_G));

      // Если вдруг дата начала пустая или выходит за рамки расчетного
      // месяца, то установим ее равной первому числу расчетного месяца
      if ( Date.IsEqI(INVALID_DATE_VALUE) || Date.LT(DateBPer) )
         Date.SetDate(DateBPer.GetStr());

      // значение кода работы и значение нормативного графика на эту дату
      int KodRab = atoi(GetKchValue("kod_rab",StrKodRab,20,DateEnd));
      int NGrafik= atoi(GetKchValue("grafik",StrNGrafik,20,DateEnd));
      if ( !NGrafik ) NGrafik = 1;

      CntWDay    = GetCountWeekDays(NGrafik);
      CntWHours  = (GetCountWeekHours(NGrafik)/CntWDay);
      if ( round_H ) roundd(CntWHours,AccRv,CntWHours); 
         
      char KodRab_period[256];
      sprintf(KodRab_period,"%s_%s_%s_%d_%f",Date.GetStr(),DateEnd.GetStr(),StrKodRab,CntWDay,CntWHours);
      nepoln += KodRab_period+";";
   }

   return SubStr(nepoln,0,strlen(nepoln)-1);   
}

CountDayChas(absm, _SimvTabel, _SimvNorm, bHoliday, type_rv)
//*********************************************************
//** Определяет количество отработанных дней/часов в месяце absm
//** SimvTabel - какие символы в табеле учитываем
//** SimvNorm  - какие символы в нормативном календаре 
//**             учитываем
//** bHoliday - учитывать (1) только праздничные дни 
//              или их не учитывать (0)
//** type_rv - тип РВ (1-дни, 0 - часы ) 
//*********************************************************
{
   int TmpMrasch = mrasch;
   s50(absm);
   
   int CountDay = 0;
   double CountHours = 0.;

   char SimvTabel[512], SimvNorm[512];
   zamena_oboz(_SimvTabel,SimvTabel);
   zamena_oboz(_SimvNorm, SimvNorm);
   string Holidays = ListHolidays(absm);
   var razb = CreateObject("ParamFuncRW");
   razb.IInitial(Holidays,",",32);
   short HolidayDay[32];
   for ( int i=0; i<razb.Count(); ++i )
   {
      HolidayDay[i]=atoi(razb.Get(i));
   }
   
   for ( int day=1; day<=countday; day++ )
   {
      int pos = poisk1(day,HolidayDay,razb.Count(),0);
      if ( (bHoliday && pos!=EOF || !bHoliday && pos==EOF) &&
           CountChar(SimvTabel,calm[day-1]) && CountChar(SimvNorm,calmras[day-1])
         )
      {
         CountDay++;
         double rv;
         skoljko(rv,data,day,day,SimvTabel,calm,0);
         CountHours += rv;
      }
   }
   
   if ( type_rv == 1 )  return CountDay;
   else                 return CountHours;
}