class Protocol < ApplicationRecord
  include SearchableModel
  include RenamingUtil

  after_save :update_linked_children
  after_destroy :decrement_linked_children

  enum protocol_type: {
    unlinked: 0,
    linked: 1,
    in_repository_private: 2,
    in_repository_public: 3,
    in_repository_archived: 4
  }

  auto_strip_attributes :name, :description, nullify: false
  # Name is required when its actually specified (i.e. :in_repository? is true)
  validates :name, length: { maximum: Constants::NAME_MAX_LENGTH }
  validates :description, length: { maximum: Constants::TEXT_MAX_LENGTH }
  validates :team, presence: true
  validates :protocol_type, presence: true

  with_options if: :in_module? do |protocol|
    protocol.validates :my_module, presence: true
    protocol.validates :published_on, absence: true
    protocol.validates :archived_by, absence: true
    protocol.validates :archived_on, absence: true
  end
  with_options if: :linked? do |protocol|
    protocol.validates :added_by, presence: true
    protocol.validates :parent, presence: true
    protocol.validates :parent_updated_at, presence: true
  end

  with_options if: :in_repository? do |protocol|
    protocol.validates :name, presence: true
    protocol.validates :added_by, presence: true
    protocol.validates :my_module, absence: true
    protocol.validates :parent, absence: true
    protocol.validates :parent_updated_at, absence: true
  end
  with_options if: :in_repository_public? do |protocol|
    # Public protocol must have unique name inside its team
    protocol
      .validates_uniqueness_of :name,
                               scope: :team,
                               conditions: -> {
                                 where(
                                   protocol_type:
                                     Protocol
                                      .protocol_types[:in_repository_public]
                                 )
                               }
    protocol.validates :published_on, presence: true
  end
  with_options if: :in_repository_private? do |protocol|
    # Private protocol must have unique name inside its team & user scope
    protocol
      .validates_uniqueness_of :name,
                               scope: [:team, :added_by],
                               conditions: -> {
                                 where(
                                   protocol_type:
                                     Protocol
                                       .protocol_types[:in_repository_private]
                                 )
                               }
  end
  with_options if: :in_repository_archived? do |protocol|
    # Archived protocol must have unique name inside its team & user scope
    protocol
      .validates_uniqueness_of :name,
                               scope: [:team, :added_by],
                               conditions: -> {
                                 where(
                                   protocol_type:
                                    Protocol
                                      .protocol_types[:in_repository_archived]
                                 )
                               }
    protocol.validates :archived_by, presence: true
    protocol.validates :archived_on, presence: true
  end

  belongs_to :added_by,
             foreign_key: 'added_by_id',
             class_name: 'User',
             inverse_of: :added_protocols,
             optional: true
  belongs_to :my_module,
             inverse_of: :protocols,
             optional: true
  belongs_to :team, inverse_of: :protocols, optional: true
  belongs_to :parent,
             foreign_key: 'parent_id',
             class_name: 'Protocol',
             optional: true
  belongs_to :archived_by,
             foreign_key: 'archived_by_id',
             class_name: 'User',
             inverse_of: :archived_protocols, optional: true
  belongs_to :restored_by,
             foreign_key: 'restored_by_id',
             class_name: 'User',
             inverse_of: :restored_protocols, optional: true
  has_many :linked_children,
           class_name: 'Protocol',
           foreign_key: 'parent_id'
  has_many :protocol_protocol_keywords,
           inverse_of: :protocol,
           dependent: :destroy
  has_many :protocol_keywords, through: :protocol_protocol_keywords
  has_many :steps, inverse_of: :protocol, dependent: :destroy

  def self.search(user,
                  include_archived,
                  query = nil,
                  page = 1,
                  _current_team = nil,
                  options = {})
    team_ids = Team.joins(:user_teams)
                   .where('user_teams.user_id = ?', user.id)
                   .distinct
                   .pluck(:id)

    module_ids = MyModule.search(user,
                                 include_archived,
                                 nil,
                                 Constants::SEARCH_NO_LIMIT)
                         .pluck(:id)

    where_str =
      '(protocol_type IN (?) AND my_module_id IN (?)) OR ' \
      '(protocol_type = ? AND protocols.team_id IN (?) AND ' \
      'added_by_id = ?) OR (protocol_type = ? AND protocols.team_id IN (?))'

    if include_archived
      where_str +=
        ' OR (protocol_type = ? AND protocols.team_id IN (?) ' \
        'AND added_by_id = ?)'
      new_query = Protocol
                  .where(
                    where_str,
                    [Protocol.protocol_types[:unlinked],
                     Protocol.protocol_types[:linked]],
                    module_ids,
                    Protocol.protocol_types[:in_repository_private],
                    team_ids,
                    user.id,
                    Protocol.protocol_types[:in_repository_public],
                    team_ids,
                    Protocol.protocol_types[:in_repository_archived],
                    team_ids,
                    user.id
                  )
    else
      new_query = Protocol
                  .where(
                    where_str,
                    [Protocol.protocol_types[:unlinked],
                     Protocol.protocol_types[:linked]],
                    module_ids,
                    Protocol.protocol_types[:in_repository_private],
                    team_ids,
                    user.id,
                    Protocol.protocol_types[:in_repository_public],
                    team_ids
                  )
    end

    new_query = new_query
                .distinct
                .joins('LEFT JOIN protocol_protocol_keywords ON ' \
                       'protocols.id = protocol_protocol_keywords.protocol_id')
                .joins('LEFT JOIN protocol_keywords ' \
                       'ON protocol_keywords.id = ' \
                       'protocol_protocol_keywords.protocol_keyword_id')
                .where_attributes_like(
                  [
                    'protocols.name',
                    'protocols.description',
                    'protocols.authors',
                    'protocol_keywords.name'
                  ],
                  query, options
                )

    # Show all results if needed
    if page == Constants::SEARCH_NO_LIMIT
      new_query
    else
      new_query
        .limit(Constants::SEARCH_LIMIT)
        .offset((page - 1) * Constants::SEARCH_LIMIT)
    end
  end

  def linked_modules
    MyModule.joins(:protocols).where('protocols.parent_id = ?', id)
  end

  def linked_experiments(linked_mod)
    Experiment.where('id IN (?)', linked_mod.pluck(:experiment_id).uniq)
  end

  def linked_projects(linked_exp)
    Project.where('id IN (?)', linked_exp.pluck(:project_id).uniq)
  end

  def self.new_blank_for_module(my_module)
    Protocol.new(
      team: my_module.experiment.project.team,
      protocol_type: :unlinked,
      my_module: my_module
    )
  end

  # Deep-clone given array of assets
  def self.deep_clone_assets(assets_to_clone, team)
    assets_to_clone.each do |src_id, dest_id|
      src = Asset.find_by_id(src_id)
      dest = Asset.find_by_id(dest_id)
      if src.present? and dest.present? then
        # Clone file
        dest.file = src.file
        dest.save

        # Clone extracted text data if it exists
        if (atd = src.asset_text_datum).present? then
          atd2 = AssetTextDatum.new(
            data: atd.data,
            asset: dest
          )
          atd2.save
        end

        # Update estimated size of cloned asset
        # (& file_present flag)
        dest.update(
          estimated_size: src.estimated_size,
          file_present: true
        )

        # Update team's space taken
        team.reload
        team.take_space(dest.estimated_size)
        team.save
      end
    end
  end

  def self.clone_contents(src, dest, current_user, clone_keywords)
    assets_to_clone = []

    # Update keywords
    if clone_keywords then
      src.protocol_keywords.each do |keyword|
        ProtocolProtocolKeyword.create(
          protocol: dest,
          protocol_keyword: keyword
        )
      end
    end

    # Copy steps
    src.steps.each do |step|
      step2 = Step.new(
        name: step.name,
        description: step.description,
        position: step.position,
        completed: false,
        user: current_user,
        protocol: dest)
      step2.save

      # Copy checklists
      step.checklists.asc.each do |checklist|
        checklist2 = Checklist.new(
          name: checklist.name,
          step: step2
          )
        checklist2.created_by = current_user
        checklist2.last_modified_by = current_user
        checklist2.save

        checklist.checklist_items.each do |item|
          item2 = ChecklistItem.new(
            text: item.text,
            checked: false,
            checklist: checklist2,
            position: item.position
          )
          item2.created_by = current_user
          item2.last_modified_by = current_user
          item2.save
        end

        step2.checklists << checklist2
      end

      # "Shallow" Copy assets
      step.assets.each do |asset|
        asset2 = Asset.new_empty(
          asset.file_file_name,
          asset.file_file_size
        )
        asset2.created_by = current_user
        asset2.team = dest.team
        asset2.last_modified_by = current_user
        asset2.file_processing = true if asset.is_image?
        asset2.save

        step2.assets << asset2
        if asset.is_image?
          asset2.file.delay.reprocess!(:large)
          asset2.file.delay.reprocess!(:medium)
        end
        assets_to_clone << [asset.id, asset2.id]
      end

      # Copy tables
      step.tables.each do |table|
        table2 = Table.new(
          name: table.name,
          contents: table.contents.encode('UTF-8', 'UTF-8')
        )
        table2.created_by = current_user
        table2.last_modified_by = current_user
        table2.team = dest.team
        step2.tables << table2
      end
    end

    # Call clone helper
    Protocol.delay(queue: :assets).deep_clone_assets(
      assets_to_clone,
      dest.team
    )
  end

  def in_repository_active?
    in_repository_private? || in_repository_public?
  end

  def in_repository?
    in_repository_active? || in_repository_archived?
  end

  def in_module?
    unlinked? || linked?
  end

  def linked_no_diff?
    linked? &&
      updated_at == parent_updated_at &&
      parent.updated_at == parent_updated_at
  end

  def newer_than_parent?
    linked? && parent.updated_at == parent_updated_at &&
      updated_at > parent_updated_at
  end

  def parent_newer?
    linked? &&
      updated_at == parent_updated_at &&
      parent.updated_at > parent_updated_at
  end

  def parent_and_self_newer?
    linked? &&
      parent.updated_at > parent_updated_at &&
      updated_at > parent_updated_at
  end

  def number_of_steps
    steps.count
  end

  def completed_steps
    steps.where(completed: true)
  end

  def space_taken
    st = 0
    self.steps.find_each do |step|
      st += step.space_taken
    end
    st
  end

  def make_private(user)
    # Don't update "updated_at" timestamp
    self.record_timestamps = false

    self.added_by = user
    self.published_on = nil
    self.archived_by = nil
    self.archived_on = nil
    self.restored_by = nil
    self.restored_on = nil
    self.protocol_type = Protocol.protocol_types[:in_repository_private]
    save
  end

  # This publish action simply moves the protocol from
  # the private section in the repository into the public
  # section
  def publish(user)
    # Don't update "updated_at" timestamp
    self.record_timestamps = false

    self.added_by = user
    self.published_on = Time.now
    self.archived_by = nil
    self.archived_on = nil
    self.restored_by = nil
    self.restored_on = nil
    self.protocol_type = Protocol.protocol_types[:in_repository_public]
    save
  end

  def archive(user)
    return nil unless can_destroy?

    # Don't update "updated_at" timestamp
    self.record_timestamps = false

    # We keep published_on present, so we know (upon restoring)
    # where the protocol was located

    self.archived_by = user
    self.archived_on = Time.now
    self.restored_by = nil
    self.restored_on = nil
    self.protocol_type = Protocol.protocol_types[:in_repository_archived]
    result = save

    # Update all module protocols that had
    # parent set to this protocol
    if result then
      Protocol.where(parent: self).find_each do |p|
        p.update(
          parent: nil,
          parent_updated_at: nil,
          protocol_type: :unlinked
        )
      end
    end

    result
  end

  def restore(user)
    # Don't update "updated_at" timestamp
    self.record_timestamps = false

    self.archived_by = nil
    self.archived_on = nil
    self.restored_by = user
    self.restored_on = Time.now
    if self.published_on.present?
      self.published_on = Time.now
      self.protocol_type = Protocol.protocol_types[:in_repository_public]
    else
      self.protocol_type = Protocol.protocol_types[:in_repository_private]
    end
    save
  end

  def update_keywords(keywords)
    result = true
    begin
      Protocol.transaction do
        self.record_timestamps = false

        # First, destroy all keywords
        self.protocol_protocol_keywords.destroy_all
        if keywords.present?
          keywords.each do |kw_name|
            kw = ProtocolKeyword.find_by(name: kw_name)
            if kw.blank?
              kw = ProtocolKeyword.create(
                name: kw_name,
                team: self.team
              )
            end
            self.protocol_keywords << kw
          end
        end
      end
    rescue
      result = false
    end
    result
  end

  def unlink
    self.parent = nil
    self.parent_updated_at = nil
    self.protocol_type = Protocol.protocol_types[:unlinked]
    self.save!
  end

  def update_parent(current_user)
    # First, destroy parent's step contents
    parent.destroy_contents(current_user)
    parent.reload

    # Now, clone step contents
    Protocol.clone_contents(self, self.parent, current_user, false)

    # Lastly, update the metadata
    parent.reload
    parent.record_timestamps = false
    parent.updated_at = self.updated_at
    parent.save!
    self.record_timestamps = false
    self.parent_updated_at = self.updated_at
    self.save!
  end

  def update_from_parent(current_user)
    # First, destroy step contents
    destroy_contents(current_user)

    # Now, clone parent's step contents
    Protocol.clone_contents(self.parent, self, current_user, false)

    # Lastly, update the metadata
    self.reload
    self.record_timestamps = false
    self.updated_at = self.parent.updated_at
    self.parent_updated_at = self.parent.updated_at
    self.added_by = current_user
    self.save!
  end

  def load_from_repository(source, current_user)
    # First, destroy step contents
    destroy_contents(current_user)

    # Now, clone source's step contents
    Protocol.clone_contents(source, self, current_user, false)

    # Lastly, update the metadata
    self.reload
    self.record_timestamps = false
    self.updated_at = source.updated_at
    self.parent = source
    self.parent_updated_at = source.updated_at
    self.added_by = current_user
    self.protocol_type = Protocol.protocol_types[:linked]
    self.save!
  end

  def copy_to_repository(new_name, new_protocol_type, link_protocols, current_user)
    clone = Protocol.new(
      name: new_name,
      protocol_type: new_protocol_type,
      added_by: current_user,
      team: self.team
    )
    if clone.in_repository_public?
      clone.published_on = Time.now
    end

    # Don't proceed further if clone is invalid
    if clone.invalid?
      return clone
    end

    # Okay, clone seems to be valid: let's clone it
    clone = deep_clone(clone, current_user)

    # If the above operation went well, update published_on
    # timestamp
    if clone.in_repository_public?
      clone.update(published_on: Time.now)
    end

    # Link protocols if neccesary
    if link_protocols then
      self.reload
      self.record_timestamps = false
      self.added_by = current_user
      self.parent = clone
      ts = clone.updated_at
      self.parent_updated_at = ts
      self.updated_at = ts
      self.protocol_type = Protocol.protocol_types[:linked]
      self.save!
    end

    return clone
  end

  def deep_clone_my_module(my_module, current_user)
    clone = Protocol.new_blank_for_module(my_module)
    clone.name = self.name
    clone.authors = self.authors
    clone.description = self.description
    clone.protocol_type = self.protocol_type

    if self.linked?
      clone.added_by = current_user
      clone.parent = self.parent
      clone.parent_updated_at = self.parent_updated_at
    end

    deep_clone(clone, current_user)
  end

  def deep_clone_repository(current_user)
    clone = Protocol.new(
      name: self.name,
      authors: self.authors,
      description: self.description,
      added_by: current_user,
      team: self.team,
      protocol_type: self.protocol_type,
      published_on: self.in_repository_public? ? Time.now : nil,
    )

    deep_clone(clone, current_user)
  end

  def destroy_contents(current_user)
    # Calculate total space taken by the protocol
    st = self.space_taken

    self.steps.find_each do |step|
      unless step.destroy(current_user) then
        raise ActiveRecord::RecordNotDestroyed
      end
    end

    # Release space taken by the step
    self.team.release_space(st)
    self.team.save

    # Reload protocol
    self.reload
  end

  def can_destroy?
    steps.map(&:can_destroy?).all?
  end

  private

  def deep_clone(clone, current_user)
    # Save cloned protocol first
    success = clone.save

    # Rename protocol if needed
    unless success
      rename_record(clone, :name)
      success = clone.save
    end

    raise ActiveRecord::RecordNotSaved unless success

    Protocol.clone_contents(self, clone, current_user, true)

    clone.reload
    clone
  end

  def update_linked_children
    # Increment/decrement the parent's nr of linked children
    if saved_change_to_parent_id?
      unless parent_id_before_last_save.nil?
        p = Protocol.find_by_id(parent_id_before_last_save)
        p.record_timestamps = false
        p.decrement!(:nr_of_linked_children)
      end
      if self.parent_id != nil
        self.parent.record_timestamps = false
        self.parent.increment!(:nr_of_linked_children)
      end
    end
  end

  def decrement_linked_children
    self.parent.decrement!(:nr_of_linked_children) if self.parent.present?
  end

end