using System;
using System.Collections.Generic;
using System.Linq;
using Sungero.Core;
using Sungero.CoreEntities;
using DirRX.LongTermArchive.CaseFile;

namespace DirRX.LongTermArchive.Client
{
  partial class CaseFileCollectionActions
  {

    public virtual bool CanRemoveCaseFilesFromInventoryDirRX(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      // Можно выполнить только если номенклатура дел вызвана из контекста электронной описи.
      return CallContext.CalledFrom(CaseArchiving.CaseInventories.Info);
    }
    
    public virtual void RemoveCaseFilesFromInventoryDirRX(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      var error = string.Empty;
      
      // Документ, из которого открыта номенклатура дел.
      var document = CaseArchiving.PublicFunctions.Module.Remote.GetCaseInventory(CallContext.GetCallerEntityId(CaseArchiving.CaseInventories.Info));
      
      if (document.InternalApprovalState == CaseArchiving.CaseInventory.InternalApprovalState.Signed)
        error = CaseArchiving.CaseInventories.Resources.WarningCaseInventoryAlreadySigned.ToString();
      else if (document.ArchiveDate.HasValue)
        error = CaseArchiving.CaseInventories.Resources.WarningCaseInventoryAlreadyArchived.ToString();
      else if (Users.Current != null && Users.Current.IsSystem != true && document.Responsible != null &&
               document.Responsible != Storage.PublicFunctions.Module.Remote.GetEmployeeForCurentUser())
      {
        // Исключать дела из описи может только ответственный делопроизводитель.
        error = CaseArchiving.CaseInventories.Resources.WarningOnlyResponsibleCanRemoveCaseFilesFormat(document.Responsible.DisplayValue);
      }
      else
      {
        // Исключить отмеченные в списке дела из описи.
        error = CaseArchiving.PublicFunctions.CaseInventory.RemoveCaseFilesDialog(document, _objs.ToList());
      }
      
      if (error != string.Empty)
        Dialogs.ShowMessage(error, MessageType.Warning);
    }

    public virtual bool CanRemoveCaseFilesFromDestructionActDirRX(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      // Можно выполнить только если номенклатура дел вызвана из контекста акта об уничтожении.
      return CallContext.CalledFrom(Storage.DestructionActs.Info);
    }

    public virtual void RemoveCaseFilesFromDestructionActDirRX(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      var error = string.Empty;
      
      // Документ, из которого открыта номенклатура дел.
      var document = Storage.PublicFunctions.Module.Remote.GetDestructionAct(CallContext.GetCallerEntityId(Storage.DestructionActs.Info));
      
      if (document.InternalApprovalState == Storage.DestructionAct.InternalApprovalState.Signed)
        error = Storage.DestructionActs.Resources.WarningDestructionActAlreadySigned.ToString();
      else if (Users.Current != null && Users.Current.IsSystem != true && document.Archivist != null &&
               document.Archivist != Storage.PublicFunctions.Module.Remote.GetEmployeeForCurentUser())
      {
        // Исключать дела может только архивист.
        error = Storage.DestructionActs.Resources.WarningOnlyArchivistCanRemoveCaseFilesFormat(document.Archivist.DisplayValue);
      }
      else
      {
        // Исключить отмеченные в списке дела из документа.
        error = Storage.PublicFunctions.DestructionAct.RemoveCaseFilesDialog(document, _objs.ToList());
      }
      
      if (error != string.Empty)
        Dialogs.ShowMessage(error, MessageType.Warning);
    }

    public virtual bool CanRemoveCaseFilesFromConsInventoryDirRX(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      // Можно выполнить только если номенклатура дел вызвана из контекста сводной описи.
      return CallContext.CalledFrom(Storage.ConsolidatedInventories.Info) && !CallContext.CalledFrom(Storage.AnnualSections.Info) &&
        Storage.ConsolidatedInventories.Get(CallContext.GetCallerEntityId(Storage.ConsolidatedInventories.Info)).Status == Storage.ConsolidatedInventory.Status.Active;
    }

    public virtual void RemoveCaseFilesFromConsInventoryDirRX(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      // Проверить, что текущий пользователь является архивистом (имеет права на исключение дел из описи).
      var employees = DirRX.CaseArchiving.PublicFunctions.Module.Remote.GetEmployeesForArchivistRole();
      if (Users.Current != null && Users.Current.IsSystem != true && Sungero.Company.Employees.Current != null && !employees.Contains(Storage.PublicFunctions.Module.Remote.GetEmployeeForCurentUser()))
      {
        Dialogs.ShowMessage(Storage.ConsolidatedInventories.Resources.WarningOnlyArchivistCanRemoveCaseFiles.ToString(), MessageType.Warning);
        return;
      }

      // Получить опись, из которой открыта номенклатура дел.
      var inventory = Storage.PublicFunctions.Module.Remote.GetConsolidatedInventory(CallContext.GetCallerEntityId(Storage.ConsolidatedInventories.Info));
      
      // Получить список отмеченных дел для исключения.
      var caseFileList = _objs.ToList();
      var needDialog = false;
      var approvedExistMessage = string.Empty;
      
      // Если дела не были отмечены в списке, получить все дела описи.
      if (!caseFileList.Any())
      {
        caseFileList.AddRange(Storage.PublicFunctions.ConsolidatedInventory.Remote.GetCaseFiles(inventory));
        needDialog = true;
      }
      
      if (!caseFileList.Any())
      {
        Dialogs.ShowMessage(Storage.ConsolidatedInventories.Resources.WarningCaseListIsEmpty, MessageType.Error);
        return;
      }
      
      // Оставить только дела неутвержденных годовых разделов.
      var maxApprovedSectionYear = 0;
      foreach (var year in caseFileList.Where(x => x.LTAConsInventoryYearDirRX.HasValue).OrderByDescending(x => x.LTAConsInventoryYearDirRX.Value)
               .Select(x => x.LTAConsInventoryYearDirRX.Value).Distinct())
      {
        if (DirRX.Storage.PublicFunctions.Module.Remote.ApprovedAnnualSectionExists(inventory, year))
        {
          maxApprovedSectionYear = year;
          break;
        }
      }
      
      if (maxApprovedSectionYear > 0)
      {
        approvedExistMessage = Storage.ConsolidatedInventories.Resources.ApprovedAnnualSectionExistFormat(inventory.Number, maxApprovedSectionYear);
        caseFileList = caseFileList.Where(x => !x.LTAConsInventoryYearDirRX.HasValue || x.LTAConsInventoryYearDirRX.Value > maxApprovedSectionYear).ToList();
        
        if (!caseFileList.Any())
        {
          Dialogs.ShowMessage(approvedExistMessage + " " + Storage.Resources.ConsolidatedInventoryCannotRemoveFromApprovedSection, MessageType.Error);
          return;
        }
        
        needDialog = true;
      }
      
      // Уточнить список исключаемых описей в диалоге.
      if (needDialog)
      {
        var dialog = Dialogs.CreateInputDialog(Storage.Resources.RemoveCaseFileDialogTitle);
        var caseFileSelector = dialog.AddSelectMany(Storage.Resources.CaseFilesLabel, true, DirRX.LongTermArchive.CaseFiles.Null)
          .From(caseFileList.ToArray());
        
        if (_objs.Any())
          caseFileSelector.Value = caseFileList.Where(x => _objs.Contains(x)).AsEnumerable();
        
        if (approvedExistMessage != string.Empty)
          dialog.Text = approvedExistMessage + " " + Storage.Resources.ConsolidatedInventoryRemoveLaterSectionAvailable;
        
        if (dialog.Show() == DialogButtons.Ok)
          caseFileList = caseFileSelector.Value.ToList();
        else
          return;
      }

      // Исключить дела.
      if (!caseFileList.Any())
        return;
      
      var notRemovedIds = new List<int>();
      var updatedYears = new List<int>();
      var docs = string.Empty;
      foreach (var caseFile in caseFileList)
      {
        var year = caseFile.LTAConsInventoryYearDirRX.HasValue ? caseFile.LTAConsInventoryYearDirRX.Value : 0;
        
        if (!DirRX.LongTermArchive.PublicFunctions.CaseFile.UpdateConsInventory(caseFile, null, null, null))
          notRemovedIds.Add(caseFile.Id);
        else if (year > 0 && !updatedYears.Contains(year))
        {
          updatedYears.Add(year);
          var annualSection = Storage.PublicFunctions.Module.Remote.GetAnnualSection(inventory, year);
          if (annualSection != null)
            docs += Environment.NewLine + annualSection.Name;
        }
      }
      
      if (notRemovedIds.Any())
      {
        var message = Storage.ConsolidatedInventories.Resources.WarningCanNotUpdateCaseFileFormat(caseFileList.First(x => x.Id == notRemovedIds.First()).DisplayValue);
        Dialogs.ShowMessage(message, MessageType.Error);
      }
      
      // Предупредить о необходимости переформировать годовой раздел.
      if (docs != string.Empty)
        Dialogs.ShowMessage(Storage.ConsolidatedInventories.Resources.ReformAnnualSectionMessageFormat(docs), MessageType.Warning);
    }

    public virtual bool CanCreateConsInventoryDirRX(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      return true;
    }

    public virtual void CreateConsInventoryDirRX(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      var caseFiles = _objs.Where(x => x.LTAConsInventoryDirRX == null).ToList();
      if (caseFiles.Any())
      {
        // Получить доступные сводные описи.
        var inventories = PublicFunctions.CaseFile.Remote.GetInventories(_objs.FirstOrDefault());
        
        if (caseFiles.All(x => x.LTAIsPaperDirRX.GetValueOrDefault() == true))
        {
          // Отфильтровать описи для бумажных дел.
          inventories = inventories.Where(i => i.Type == DirRX.Storage.ConsolidatedInventory.Type.Permanent ||
                                          i.Type == DirRX.Storage.ConsolidatedInventory.Type.Personnel ||
                                          i.Type == DirRX.Storage.ConsolidatedInventory.Type.Temporary);
        }
        else if (caseFiles.All(x => x.LTAIsPaperDirRX.GetValueOrDefault() == false))
        {
          // Отфильтровать описи для электронных дел.
          inventories = inventories.Where(i => i.Type == DirRX.Storage.ConsolidatedInventory.Type.ElectronicPerm ||
                                          i.Type == DirRX.Storage.ConsolidatedInventory.Type.ElectronicTemp);
        }
        else
        {
          Dialogs.ShowMessage(Storage.Resources.ConsolidatedInventoryCannotAddDifferentTypes, MessageType.Error);
          return;
        }

        var dialog = Dialogs.CreateInputDialog(Storage.Resources.AddCaseFilesToInventoryDialogTitle);
        
        var inventory = dialog.AddSelect(Storage.Resources.ConsolidatedInventoryLabel, true, Storage.ConsolidatedInventories.Null).From(inventories.ToArray());
        var year = dialog.AddInteger(Storage.Resources.YearLabel, true, Calendar.Today.Year);
        
        if (inventories.Count() == 1)
        {
          inventory.Value = inventories.First();
          var lastSection = Storage.PublicFunctions.Module.Remote.GetAnnualSection(inventory.Value, null);
          if (lastSection != null)
            year.Value = lastSection.Year;
        }
        
        dialog.SetOnRefresh((arg) =>
                            {
                              if (year.Value.HasValue && inventory.Value != null)
                              {
                                var selectedYear = year.Value.Value;
                                
                                // Проверить наличие утвержденного годового раздела.
                                var message = Storage.PublicFunctions.Module.Remote.LaterApprovedAnnualSectionsExists(inventory.Value, selectedYear);
                                
                                if (message != string.Empty)
                                {
                                  arg.AddError(message + " " + Storage.Resources.ConsolidatedInventoryAddLaterSectionAvailable);
                                  return;
                                }
                                
                                // Проверить наличе раздела для указанного года.
                                var annualSection = Storage.PublicFunctions.Module.Remote.GetAnnualSection(inventory.Value, selectedYear);
                                if (annualSection != null)
                                  arg.AddWarning(Storage.ConsolidatedInventories.Resources.ReformAnnualSectionMessageFormat(annualSection.Name));
                                else
                                  // Предупредить, что годовой раздел еще не создан.
                                  arg.AddInformation(Storage.Resources.ConsolidatedInventoryAnnualSectionNotExistFormat(inventory.Value.Number, selectedYear));
                              }
                            });
        
        if (dialog.Show() == DialogButtons.Ok)
        {
          foreach (var caseFile in caseFiles)
          {
            if (!DirRX.LongTermArchive.PublicFunctions.CaseFile.UpdateConsInventory(caseFile, inventory.Value, year.Value, string.Empty))
            {
              Storage.PublicFunctions.ConsolidatedInventory.UpdateConsolidatedInventory(inventory.Value);
              Dialogs.ShowMessage(Storage.ConsolidatedInventories.Resources.WarningCanNotUpdateCaseFileFormat(caseFile.DisplayValue), MessageType.Warning);
              return;
            }
          }
          Storage.PublicFunctions.ConsolidatedInventory.UpdateConsolidatedInventory(inventory.Value);
        }
      }
      else
        Dialogs.ShowMessage(Storage.Resources.ConsolidatedInventoryIncorrectCaseFiles, MessageType.Warning);
      
    }
  }

  internal static class CaseFileStaticActions
  {
    public static void AddCaseFilesToConsInventoryDirRX(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      var error = string.Empty;
      
      var inventory = Storage.PublicFunctions.Module.Remote.GetConsolidatedInventory(CallContext.GetCallerEntityId(Storage.ConsolidatedInventories.Info));
      
      // Добавлять дела может только архивист.
      var employees = DirRX.CaseArchiving.PublicFunctions.Module.Remote.GetEmployeesForArchivistRole();
      if (Users.Current != null && Users.Current.IsSystem != true && Sungero.Company.Employees.Current != null && !employees.Contains(Storage.PublicFunctions.Module.Remote.GetEmployeeForCurentUser()))
        error = Storage.ConsolidatedInventories.Resources.WarningOnlyArchivistCanAddCaseFiles;
      else
        error = Storage.PublicFunctions.ConsolidatedInventory.AddCaseFilesDialog(inventory);
      
      if (error != string.Empty)
        Dialogs.ShowMessage(error, MessageType.Warning);
    }

    public static bool CanAddCaseFilesToConsInventoryDirRX(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      // Можно выполнить только если номенклатура дел вызвана из контекста сводной описи.
      return CallContext.CalledFrom(Storage.ConsolidatedInventories.Info) && !CallContext.CalledFrom(Storage.AnnualSections.Info)
        && Storage.ConsolidatedInventories.Get(CallContext.GetCallerEntityId(Storage.ConsolidatedInventories.Info)).Status == Storage.ConsolidatedInventory.Status.Active;
    }

    public static void AddCaseFilesToInventoryDirRX(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      var error = string.Empty;
      
      // Опись, из которой открыта номенклатура дел.
      var document = CaseArchiving.PublicFunctions.Module.Remote.GetCaseInventory(CallContext.GetCallerEntityId(CaseArchiving.CaseInventories.Info));

      if (document.InternalApprovalState == CaseArchiving.CaseInventory.InternalApprovalState.Signed)
        error = CaseArchiving.CaseInventories.Resources.WarningCaseInventoryAlreadySigned.ToString();
      else if (document.ArchiveDate.HasValue)
        error = CaseArchiving.CaseInventories.Resources.WarningCaseInventoryAlreadyArchived.ToString();
      else if (Users.Current != null && Users.Current.IsSystem != true && document.Responsible != null &&
               document.Responsible != Storage.PublicFunctions.Module.Remote.GetEmployeeForCurentUser())
      {
        // Добавлять дела в опись может только ответственный делопроизводитель.
        error = CaseArchiving.CaseInventories.Resources.WarningOnlyResponsibleCanAddCaseFilesFormat(document.Responsible.DisplayValue);
      }
      else
        // Отобразить диалог для включения дел в опись.
        error = CaseArchiving.PublicFunctions.CaseInventory.AddCaseFilesDialog(document);
      
      if (error != string.Empty)
        Dialogs.ShowMessage(error, MessageType.Warning);
    }
    
    public static bool CanAddCaseFilesToInventoryDirRX(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      return CallContext.CalledFrom(CaseArchiving.CaseInventories.Info);
    }

    public static bool CanAddCaseFilesToDestructionActDirRX(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      // Можно выполнить только если номенклатура дел вызвана из контекста акта об уничтожении.
      return CallContext.CalledDirectlyFrom(Storage.DestructionActs.Info);
    }

    public static void AddCaseFilesToDestructionActDirRX(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      var error = string.Empty;
      
      var document = Storage.PublicFunctions.Module.Remote.GetDestructionAct(CallContext.GetCallerEntityId(Storage.DestructionActs.Info));
      
      if (document.InternalApprovalState == Storage.DestructionAct.InternalApprovalState.Signed)
        error = Storage.DestructionActs.Resources.WarningDestructionActAlreadySigned.ToString();
      else if (Users.Current != null && Users.Current.IsSystem != true && document.Archivist != null &&
               document.Archivist != Storage.PublicFunctions.Module.Remote.GetEmployeeForCurentUser())
      {
        error = Storage.DestructionActs.Resources.WarningOnlyArchivistCanAddCaseFilesFormat(document.Archivist.DisplayValue);
      }
      else
        error = Storage.PublicFunctions.DestructionAct.AddCaseFilesDialog(document);
      
      if (error != string.Empty)
        Dialogs.ShowMessage(error, MessageType.Warning);
    }
  }

  partial class CaseFileActions
  {
    public virtual void RemoveFromConsInventoryDirRX(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      var inventory = _obj.LTAConsInventoryDirRX;
      var year = _obj.LTAConsInventoryYearDirRX.Value;
      
      // Проверить наличие утвержденного годового раздела.
      var message = string.Empty;
      if (Storage.PublicFunctions.Module.Remote.ApprovedAnnualSectionExists(inventory, year))
        message += Storage.ConsolidatedInventories.Resources.ApprovedAnnualSectionExistFormat(inventory.Number, year);
      else
      {
        // Проверить наличие неутвержденного раздела.
        var annualSection = Storage.PublicFunctions.Module.Remote.GetAnnualSection(inventory, year);
        if (annualSection != null)
          message = Storage.ConsolidatedInventories.Resources.ReformAnnualSectionMessageFormat(annualSection.Name);
      }

      _obj.LTAConsInventoryDirRX = null;
      _obj.LTAConsInventoryYearDirRX = null;
      _obj.LTANumInConsInventDirRX = null;
      _obj.LTAIsSymbolNumDirRX = false;
      _obj.Save();

      Storage.PublicFunctions.ConsolidatedInventory.UpdateConsolidatedInventory(inventory);
      
      if (message != string.Empty)
        Dialogs.ShowMessage(message, MessageType.Warning);
    }

    public virtual bool CanRemoveFromConsInventoryDirRX(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      return _obj.LTAConsInventoryDirRX != null && _obj.LTAConsInventoryDirRX.Status == Sungero.CoreEntities.DatabookEntry.Status.Active;
    }

    public virtual void ChageDestructDateDirRX(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      var dialog = Dialogs.CreateInputDialog(Storage.Resources.ChangeDestructionDateDialogTitle);
      var date = dialog.AddDate(Storage.Resources.DateDestruction, true, _obj.LTADestructionDateDirRX);
      if (dialog.Show() == DialogButtons.Ok)
      {
        _obj.LTADestructionDateDirRX = date.Value;
        _obj.Save();
      }
    }

    public virtual bool CanChageDestructDateDirRX(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      return true;
    }

    public virtual void AddToConsInventoryDirRX(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      var dialog = Dialogs.CreateInputDialog(Storage.Resources.AddCaseFilesToInventoryDialogTitle);
      
      // Выбрать описи с числом дела не превышающим максимальное.
      var inventories = PublicFunctions.CaseFile.Remote.GetInventories(_obj);      
      
      // Фильтровать по виду описи в зависимости от бумажности дела.
      if (_obj.LTAIsPaperDirRX.GetValueOrDefault())
        inventories = inventories.Where(i => i.Type == DirRX.Storage.ConsolidatedInventory.Type.Permanent ||
                                        i.Type == DirRX.Storage.ConsolidatedInventory.Type.Personnel ||
                                        i.Type == DirRX.Storage.ConsolidatedInventory.Type.Temporary);
      else
        inventories = inventories.Where(i => i.Type == DirRX.Storage.ConsolidatedInventory.Type.ElectronicPerm ||
                                        i.Type == DirRX.Storage.ConsolidatedInventory.Type.ElectronicTemp);
      
      var inventory = dialog.AddSelect(Storage.Resources.ConsolidatedInventoryLabel, true, Storage.ConsolidatedInventories.Null).From(inventories.ToArray());
      var year = dialog.AddInteger(Storage.Resources.YearLabel, true, Calendar.Today.Year);

      if (inventories.Count() == 1)
      {
        inventory.Value = inventories.First();
        var lastSection = Storage.PublicFunctions.Module.Remote.GetAnnualSection(inventory.Value, null);
        if (lastSection != null)
          year.Value = lastSection.Year;
      }
      
      var number = dialog.AddString(Storage.Resources.NumberLabel, false, string.Empty);
      number.IsVisible = false;
      
      dialog.SetOnRefresh((arg) =>
                          {
                            var selectedInventory = inventory.Value;
                            if (year.Value.HasValue && selectedInventory != null)
                            {
                              var selectedYear = year.Value.Value;
                              
                              // Если годовой раздел для выбранной описи уже утвержден, открыть для редактирования обязательное свойство "Литерный номер".
                              var approved = Storage.PublicFunctions.Module.Remote.ApprovedAnnualSectionExists(selectedInventory, selectedYear);
                              number.IsVisible = approved;
                              number.IsRequired = approved;
                              if (!approved)
                              {
                                number.Value = string.Empty;
                                var error = Storage.PublicFunctions.Module.Remote.LaterApprovedAnnualSectionsExists(selectedInventory, selectedYear);
                                if (error != string.Empty)
                                {
                                  arg.AddError(error);
                                  return;
                                }
                              }
                              else
                                arg.AddWarning(Storage.ConsolidatedInventories.Resources.ApprovedAnnualSectionExistFormat(selectedInventory.Number, selectedYear));
                              
                              
                              // Проверить наличие годового раздела.
                              var annualSection = Storage.PublicFunctions.Module.Remote.GetAnnualSection(selectedInventory, selectedYear);
                              if (annualSection != null)
                                arg.AddWarning(Storage.ConsolidatedInventories.Resources.ReformAnnualSectionMessageFormat(annualSection.Name));
                              else
                                arg.AddInformation(Storage.Resources.ConsolidatedInventoryAnnualSectionNotExistFormat(selectedInventory.Number, selectedYear));
                              
                              int numberInt;
                              if (number.Value != string.Empty && int.TryParse(number.Value, out numberInt))
                              {
                                arg.AddError("Номер должен содержать литеру.");
                                return;
                              }
                            }
                          });
      
      if (dialog.Show() == DialogButtons.Ok)
      {
        int numInt;
        _obj.LTAConsInventoryDirRX = inventory.Value;
        _obj.LTAConsInventoryYearDirRX = year.Value.Value;
        _obj.LTANumInConsInventDirRX = number.Value;
        _obj.LTAIsSymbolNumDirRX = number.Value == string.Empty || !int.TryParse(number.Value, out numInt);
        _obj.Save();
        Storage.PublicFunctions.ConsolidatedInventory.UpdateConsolidatedInventory(inventory.Value);
      }
    }

    public virtual bool CanAddToConsInventoryDirRX(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      return _obj.LTAConsInventoryDirRX == null && _obj.LTAStageDirRX == DirRX.LongTermArchive.CaseFile.LTAStageDirRX.ArchivedDirRX;
    }

    // Переоткрыть дело для списания документов.
    public virtual void ReopenCaseFileDirRX(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      _obj.LTAStageDirRX = LTAStageDirRX.InWork;
      _obj.Status = Status.Active;
      _obj.LTADestructionDateDirRX = null;
      _obj.Save();
      Functions.CaseFile.SetStateProperties(_obj);
    }
    
    public virtual bool CanReopenCaseFileDirRX(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      return _obj.LTAStageDirRX == LTAStageDirRX.CompletedDirRX;
    }

    // Завершить формирование дела.
    public virtual void CloseCaseFileDirRX(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      // Проверить подразделение, если включена настройка "Формировать описи в разрезе подразделений".
      if (CaseArchiving.PublicFunctions.Module.Remote.IsCreateCaseInventoryByDepartments())
      {
        if (_obj.Department == null)
        {
          // Проверить обязательность.
          _obj.State.Properties.Department.IsRequired = true;
          e.Validate();
          return;
        }
        else
        {
          // Проверить соответствие подразделения в документах.
          var invalidDocuments = Functions.CaseFile.Remote.GetInvalidDocuments(_obj).ToList();
          
          if (invalidDocuments.Any())
            e.AddError(DirRX.LongTermArchive.CaseFiles.Resources.ErrorInvalidDocumentsFound, _obj.Info.Actions.ShowInvalidDocumentsDirRX);
        }
      }
      
      // Отобразить диалог с параметрами для формирования описи дел.
      var dialog = Dialogs.CreateInputDialog(DirRX.LongTermArchive.CaseFiles.Resources.CompleteDialogTitle, DirRX.LongTermArchive.CaseFiles.Resources.CompleteDialogText);

      // Если дело бумажное - заполнить количество листов.
      var isPaper = _obj.LTAIsPaperDirRX.HasValue && _obj.LTAIsPaperDirRX.Value;
      var sheetsCount = dialog.AddInteger(DirRX.LongTermArchive.CaseFiles.Resources.PagesCount, false, _obj.LTASheetsCountDirRX.GetValueOrDefault());
      sheetsCount.IsVisible = isPaper;
      sheetsCount.IsRequired = isPaper;
      
      // Получить виды описей электронных или бумажных дел.
      var inventoryKinds = isPaper ? CaseArchiving.PublicFunctions.Module.Remote.GetPaperCaseInvenoryDocumentKinds() : CaseArchiving.PublicFunctions.Module.Remote.GetCaseInvenoryDocumentKinds();
      
      var defaultKind = _obj.LTAInventoryKindDirRX != null ? _obj.LTAInventoryKindDirRX : inventoryKinds.First();
      var documentKind = dialog.AddSelect(DirRX.LongTermArchive.CaseFiles.Resources.CompleteDialogDocumentKindLabel, true, defaultKind).From(inventoryKinds.ToArray());

      var responsible = dialog.AddSelect(DirRX.LongTermArchive.CaseFiles.Resources.CompleteDialogResponsibleLabel, true, _obj.LTAResponsibleDirRX);
      
      if (Users.Current != null && Users.Current.IsSystem != true)
        responsible.Value = Storage.PublicFunctions.Module.Remote.GetEmployeeForCurentUser();      
      
      var destructionDate = dialog.AddDate(DirRX.Storage.Resources.DestructionDateLabel, true);
      if (_obj.EndDate.HasValue && _obj.RetentionPeriod != null && _obj.RetentionPeriod.RetentionPeriod.HasValue)
        destructionDate.Value = new DateTime(_obj.EndDate.Value.AddYears((int)_obj.RetentionPeriod.RetentionPeriod + 1).Year, 1, 1);
      
      dialog.SetOnRefresh(x =>
                          {
                            if (x.IsValid)
                            {
                              if (sheetsCount.Value.HasValue && sheetsCount.Value.Value > DirRX.LongTermArchive.Constants.Docflow.CaseFile.MaxPages)
                                x.AddError(DirRX.LongTermArchive.CaseFiles.Resources.ErrorMaxPagesFormat(DirRX.LongTermArchive.Constants.Docflow.CaseFile.MaxPages));
                            }
                          });
      
      if (dialog.Show() == DialogButtons.Ok)
      {
        // Записать кол-во листов в деле
        if (sheetsCount.Value != null && sheetsCount.Value != 0)
          _obj.LTASheetsCountDirRX = sheetsCount.Value;
        
        // Заполнить параметры описи. Изменить статусы.
        _obj.LTAResponsibleDirRX = responsible.Value;
        _obj.LTAInventoryKindDirRX = documentKind.Value;
        _obj.LTAStageDirRX = LTAStageDirRX.CompletedDirRX;
        _obj.Status = Status.Closed;
        
        // Заполнить плановую дату уничтожения.
        _obj.LTADestructionDateDirRX = destructionDate.Value;
        
        _obj.Save();
        
        // Закрыть карточку от редактирования.
        Functions.CaseFile.SetStateProperties(_obj);
      }
      
    }

    public virtual bool CanCloseCaseFileDirRX(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      return _obj.LTAStageDirRX.Value == LTAStageDirRX.InWork;
    }

    public override void ShowDocuments(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      base.ShowDocuments(e);
    }

    public override bool CanShowDocuments(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      return base.CanShowDocuments(e);
    }

    public virtual void ShowInvalidDocumentsDirRX(Sungero.Domain.Client.ExecuteActionArgs e)
    {
      Functions.CaseFile.Remote.GetInvalidDocuments(_obj).Show();
    }

    public virtual bool CanShowInvalidDocumentsDirRX(Sungero.Domain.Client.CanExecuteActionArgs e)
    {
      return _obj.Department != null;
    }

  }
}