Class: TaxonName

Inherits:

ApplicationRecord

Object
ActiveRecord::Base
ApplicationRecord
TaxonName

show all

Includes:: Housekeeping, Shared::AlternateValues, Shared::Citations, Shared::Confidences, Shared::DataAttributes, Shared::Depictions, Shared::HasPapertrail, Shared::Identifiers, Shared::IsData, Shared::Labels, Shared::MatrixHooks::Dynamic, Shared::MatrixHooks::Member, Shared::Notes, Shared::Tags, SoftValidation, MatrixHooks, OtuSyncronization

Defined in:: app/models/taxon_name.rb

Overview

A taxon name (nomenclature only). See also NOMEN (github.com/SpeciesFileGroup/nomen).

rubocop:disable Metrics/ClassLength

Direct Known Subclasses

Combination, Hybrid, Protonym

Defined Under Namespace

Modules: MatrixHooks, OtuSyncronization

Constant Summary collapse

ALTERNATE_VALUES_FOR = Allows users to provide arbitrary annotations that “over-ride” rank string

[:rank_class].freeze

COMBINATION_ELEMENTS =

[:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS =

%w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Dash is allowed?

Regexp.new(/[^a-zA-Z|\-]/).freeze

NO_CACHED_MESSAGE =

'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID =

{
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

Constants included from SoftValidation

SoftValidation::ANCESTORS_WITH_SOFT_VALIDATIONS

Instance Attribute Summary collapse

#also_create_otu ⇒ Boolean

When true, also creates an OTU that is tied to this taxon name.
#cached ⇒ String

Genus-species combination for genus and lower, monominal for higher.
#cached_author ⇒ String^?

Author string without parentheses.
#cached_author_year ⇒ String^?

Author and year string with parentheses where necessary, i.e.
#cached_classified_as ⇒ String

if the name was classified in different group (e.g. a genus placed in wrong family).
#cached_html ⇒ String

As in ‘cached` but with tags.
#cached_misspelling ⇒ Boolean

if the name is a misspelling, stores True.
#cached_original_combination ⇒ String

Name as formed in original combination, no author/year, without HTML.
#cached_original_combination_html ⇒ String

As cached_original_combination but with HTML.
#cached_primary_homonym ⇒ String

original genus and species name.
#cached_primary_homonym_alternative_spelling ⇒ String

Original genus and species name in alternative spelling.
#cached_secondary_homonym ⇒ String

current genus and species name.
#cached_secondary_homonym_alternative_spelling ⇒ String

Current genus and species name in alternative spelling.
#etymology ⇒ String

the derivation and history of the name in written form.
#feminine_name ⇒ String

Species name which are adjective or participle change depending on the gender of the genus.
#masculine_name ⇒ String

Species name which are adjective or participle change depending on the gender of the genus.
#name ⇒ String^?

the fully latinized string (monominal) of a code governed taxonomic biological name not applicable for Combinations, they are derived from their pieces.
#neuter_name ⇒ String

Species name which are adjective or participle change depending on the gender of the genus.
#no_cached ⇒ Boolean

When true cached values are not built.
#parent_id ⇒ Integer

The id of the parent taxon.
#project_id ⇒ Integer

the project ID.
#rank_class ⇒ NomenclaturalRank class

Rank as a NomenclaturalRank class, like NomenclaturalRank::Iczn::SpeciesGroup::Species.
#taxonomy(rebuild = false) ⇒ Object readonly

See attr_reader.
#type ⇒ String

The subclass of this taxon name, e.g.
#verbatim_author ⇒ String

the verbatim author string as provided ? is not post-filled in when Source is referenced !?.
#verbatim_name ⇒ String

a representation of what the Combination (fully spelled out) or Protonym (monominal) *looked like* in its originating publication.
#year_of_publication ⇒ Integer

Sensu ICZN - the 4 digit year when this name was published, i.e.

Class Method Summary collapse

.calculated_invalid ⇒ Object
.calculated_valid ⇒ Object
.foo(rank_classes) ⇒ Object

TODO: what is this:!? :).
.not_leaves ⇒ Object

TODO: belongs in lib/queries/filter.rb likely.
.out_of_scope_combinations(taxon_name_id) ⇒ Scope

!! When :cached_valid_taxon_name_id is properly set then this method is not required rather you should use :historical_taxon_names.
.parent ⇒ Object

TODO: This method can be placed elsewhere inside this class (or even removed if not used) when github.com/ClosureTree/closure_tree/issues/346 is fixed.
.select_optimized(user_id, project_id, target: nil) ⇒ Hash
.sort_by_rank(taxon_names) ⇒ Array of TaxonName

Ordered by rank, a scope-like hack.
.used_recently(user_id, project_id, target: nil) ⇒ Array
.used_recently_in_classifications(user_id, project_id) ⇒ Scope

All taxon names attached to relationships recently created by user.
.used_recently_in_relationships(user_id, project_id) ⇒ Scope

All taxon names attached to relationships recently created by user.
.with_taxon_name_relationship(relationship) ⇒ Object

Instance Method Summary collapse

#all_taxon_name_relationships ⇒ Array

All TaxonNameRelationships where this taxon is an object or subject.
#ancestor_at_rank(rank, include_self = false) ⇒ TaxonName^?

An ancestor at the specified rank.
#ancestor_hash ⇒ Object

Hash { ‘family’ => ‘Aidae’, …}.
#ancestor_protonyms ⇒ Array of TaxonName

Ancestors of type ‘Protonym’.
#ancestors_through_parents(result = [self], start = self) ⇒ Array

Of TaxonName same as self.ancestors.to_a, but also works for new records when parents specified.
#author_string ⇒ String^?

Important, string format priority is 1) as provided verbatim 2) as generated from People 3) as taken from the Source Source People (Authors) Source Verbatim authors.
#cached_html_name_and_author_year ⇒ String

Combination of cached_html and cached_author_year.
#cached_html_original_name_and_author_year ⇒ String

Combination of cached_original_combination_html and original_author_year.
#cached_name_and_author_year ⇒ String

Combination of cached and cached_author_year.
#check_for_children ⇒ Object protected
#check_new_parent_class ⇒ Object protected

TODO: move to Protonym when we eliminate TaxonName.new().
#check_new_rank_class ⇒ Object protected

Note- prior version prevented groups from moving when set in error, and was far too strict.
#classification_invalid_or_unavailable? ⇒ Boolean

Whether this name has any classification asserting that this the name is NOT valid or that it is unavailable.
#classification_unavailable? ⇒ Boolean

Whether this name has any classification asserting that this the name is unavailable.
#classification_valid? ⇒ Boolean

True if this name has any classification asserting that it is valid.
#clear_cached(update: false) ⇒ Object
#combination_list_all ⇒ Array of Protonym

All of the names this name has been in combination with.
#combination_list_self ⇒ Array of Protonym

For all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?).
#combined_statuses ⇒ Array of String

The unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships.
#create_otu ⇒ Object
#descendant_protonyms ⇒ Array of TaxonName

Descendants of type ‘Protonym’.
#descendants_at_rank(rank) ⇒ Object
#first_possible_invalid_taxan_name_relationship ⇒ Object
#first_possible_valid_taxon_name ⇒ TaxonName

Returns the youngest #object_taxon_name from the youngest taxon name relationship.
#first_possible_valid_taxon_name_relationship ⇒ TaxonNameRelationship

Returns youngest taxon name relationship where self is the subject.
#full_name_array ⇒ rank, ...

“section”=>[“sect.”, “Aus”], “series”=>[“ser.”, “Aus”], “species”=>[nil, “aaa”], “subspecies”=>[nil, “bbb”], “variety”=>[“var.”, “ccc”]}.
#full_name_hash ⇒ Object

!! TODO: when name is a subgenus will not grab genus !! TODO: Higher classification does not follow the same pattern ?? TODO: Replace with ‘taxonomy` object .to_h?.
#gbif_status_array ⇒ Object
#gender_class ⇒ Class^?

Gender of a genus as class.
#gender_instance ⇒ TaxonNameClassification instance^?

The gender classification of this name, if provided.
#gender_name ⇒ String^?

Gender as a string (only applicable to Genera).
#genderized_name(gender = nil) ⇒ String^?
#get_author ⇒ Object

TODO: cleanly isolate getters, setters, and cached builders TODO: remove, this is only used for a strange call in sv_checked cached.
#get_author_and_year ⇒ Object

return [String] the author and year of the name, adds parenthesis where asserted.
#get_cached_classified_as ⇒ String^?
#get_cached_misspelling ⇒ Object
#get_full_name ⇒ String^?

A monominal if names is above genus, or a full epithet if below.
#get_full_name_html(name = nil) ⇒ Object

String.
#get_genus_species(genus_option, self_option) ⇒ Object

return [String, nil, false] # TODO: fix.
#get_original_combination ⇒ Object

Stub, see subclasses TaxonNameRelationships call it for Combinations.
#get_original_combination_html ⇒ Object

Stub, see subclasses only Protonym, but TaxonNameRelationships call it for Combinations.
#get_valid_taxon_name ⇒ TaxonName

A valid taxon_name for an invalid name or self for valid name.
#icn_author_and_year(taxon) ⇒ Object
#iczn_author_and_year(taxon) ⇒ String^?

The authors, and year, with parentheses as inferred by the data.
#is_ambiguously_invalid? ⇒ Boolean

Has Classification, but no relationship describing why.
#is_candidatus? ⇒ True|False

True if this name has a TaxonNameClassification of candidatus.
#is_combination? ⇒ Boolean
#is_fossil? ⇒ True|False

True if this name has a TaxonNameClassification of Fossil.
#is_genus_or_species_rank? ⇒ Boolean

See subclasses.
#is_hybrid? ⇒ Boolean

True if this name has a TaxonNameClassification of hybrid.
#is_italicized? ⇒ Boolean

Whether this name needs italics applied.
#is_protonym? ⇒ Boolean
#is_valid? ⇒ Boolean

After all inference on the validity of a name, the result is stored in cached_valid_taxon_name_id, #is_valid checks that result.
#list_of_invalid_taxon_names ⇒ Array of TaxonName

Can’t we just use #valid_id now? DD: no this is used for validation of multiple conflicting relationships this list does not return combinations.
#matrix_row_item ⇒ {"matrix_row_item": matrix_column_item, "object": object}, false

See Shared::MatrixHooks the hash corresponding to the keyword used in this tag if it exists !! Assumes it can only be in one matrix, this is wrong !!.
#merge_to(to_taxon_name, kind) ⇒ Object
#minimum_invalidating_year ⇒ Object
#minimum_years_valid ⇒ Object
#name_in_gender(gender = nil) ⇒ Array of Strings

Names of all genera where the species was placed.
#name_is_misapplied? ⇒ Boolean

return [Boolean] whether there is an ICZN missapplication relationship present on this name.
#name_with_misspelling(gender) ⇒ String

TODO: does this form of the name contain parens for subgenus? TODO: provide a default to gender (but do NOT eliminate param) TODO: on third thought- eliminate this mess.
#next_sibling ⇒ Object

TODO: this should be paginated, not all IDs!.
#nomeclatural_history ⇒ array

returns array of hashes for history of taxon.
#nomenclature_date ⇒ Time

!! Overrides and references Shared::Citations#nomenclature_date.
#normalized_genus ⇒ Object

Protonym.
#not_binominal? ⇒ True|False

True if this name has a TaxonNameClassification of not_binominal.
#original_author_year ⇒ String^?

Derived from cached_author_year !! DO NOT USE IN building cached !! See also app/helpers/taxon_names_helper.
#out_of_scope_combinations ⇒ Object
#parent_is_set? ⇒ Boolean
#part_of_speech_class ⇒ Class

Part of speech of a species as class.
#part_of_speech_instance ⇒ Object
#part_of_speech_name ⇒ String

Part of speech of a species as string.
#previous_sibling ⇒ Object

TODO: this should be paginated, not all IDs!.
#rank ⇒ String

Rank as human readable short-form, like ‘genus’ or ‘species’.
#rank_string ⇒ String

Rank (Kindom, Phylum…) as a string, like NomenclaturalRank::Iczn::SpeciesGroup::Species.
#reified_id ⇒ String

Some observations: - reified ids are only for original combinations (for which we have no ID) - reified ids never reference gender changes because they are always in context of original combination, i.e.
#related_taxon_names ⇒ Array of TaxonName

All taxon_names which have relationships to this taxon as an object or subject.
#relationship_invalid? ⇒ Boolean

True if there is a relationship where then name is asserted to be invalid.
#safe_self_and_ancestors ⇒ Array of TaxonName

Uses parent recursion when record is new and awesome_nested_set_is_not_usable.
#set_cached ⇒ Object

TODO: We need to isolate this into 2 subclasses, 1 - cached methods that touch author/year 2 - cached methods that do not.
#set_cached_author ⇒ Object
#set_cached_author_columns ⇒ Object

See TaxonNameAuthor.
#set_cached_author_year ⇒ Object
#set_cached_classified_as ⇒ Object
#set_cached_is_valid ⇒ Object
#set_cached_nomenclature_date ⇒ Object
#set_cached_valid_taxon_name_id ⇒ Object
#set_cached_warnings ⇒ Object
#statuses_from_classifications ⇒ Array of String

The unique string labels (human readable) derived from TaxonNameClassifications.
#statuses_from_relationships ⇒ Array of String

The unique string labels derived from and TaxonNameRelationships.
#sv_cached_names ⇒ Object protected
#sv_combination_duplicates ⇒ Object protected
#sv_conflicting_subordinate_taxa ⇒ Object protected
#sv_fix_cached_names ⇒ Object protected

TODO: This can be made more specific, we don’t need to call some of the methods in set_cached It also should never be required.
#sv_fix_parent_is_valid_name ⇒ Object protected
#sv_homotypic_synonyms ⇒ Object protected
#sv_hybrid_name_relationships ⇒ Object protected
#sv_incomplete_combination ⇒ Object protected
#sv_missing_classifications ⇒ Object protected
#sv_missing_confidence_level ⇒ Object protected

TODO: this needs to go.
#sv_missing_etymology ⇒ Object protected

def sv_missing_author true # see Protonym end.
#sv_missing_original_publication ⇒ Object protected
#sv_missing_relationships ⇒ Object protected
#sv_not_synonym_of_self ⇒ Object protected

Required for synonyms of synomyms.
#sv_parent_is_valid_name ⇒ Object protected
#sv_parent_priority ⇒ Object protected
#sv_potential_homonyms ⇒ Object protected
#sv_primary_types ⇒ Object protected
#sv_single_sub_taxon ⇒ Object protected
#sv_species_gender_agreement ⇒ Object protected
#sv_two_unresolved_alternative_synonyms ⇒ Object protected
#sv_type_placement ⇒ Object protected
#sv_validate_coordinated_names ⇒ Object protected
#sv_validate_name ⇒ Object protected
#sv_validate_parent_rank ⇒ Object protected
#synonyms ⇒ Scope

Protonym(s) the **broad sense** synonyms of this name.
#taxon_name_classification_minimum_invalidating_year ⇒ Object
#taxon_name_classifications_for_statuses ⇒ Scope
#taxon_name_relationship_minimum_invalidating_year ⇒ Object

Year,nil based on TaxonNameRelationships only at present.
#unavailable_or_invalid? ⇒ Boolean

@return [Boolean] return true if name is unavailable OR invalid, else false, checks both classifications and relationships !! Should only be referenced when building cached values, all other uses should rather be ‘!is_valid?`.
#validate_one_root_per_project ⇒ Object protected
#validate_parent_from_the_same_project ⇒ Object protected
#validate_parent_is_set ⇒ Object protected
#validate_rank_class_class ⇒ Object protected

See subclasses.
#validate_source_type ⇒ Object protected
#year_integer ⇒ Integer

A 4 digit integer representing year of publication, like 1974.

Instance Attribute Details

#also_create_otu ⇒ `Boolean`

Returns When true, also creates an OTU that is tied to this taxon name.

Returns:

(Boolean) —

When true, also creates an OTU that is tied to this taxon name



195
196
197

# File 'app/models/taxon_name.rb', line 195

def also_create_otu
  @also_create_otu
end

#cached ⇒ `String`

Genus-species combination for genus and lower, monominal for higher. The string has NO html, and no author/year.

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#cached_author ⇒ `String`^?

Returns author string without parentheses.

Returns:

(String, nil) —

author string without parentheses

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#cached_author_year ⇒ `String`^?

Returns author and year string with parentheses where necessary, i.e. with context of present placement for ICZN.

Returns:

(String, nil) —

author and year string with parentheses where necessary, i.e. with context of present placement for ICZN

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#cached_classified_as ⇒ `String`

if the name was classified in different group (e.g. a genus placed in wrong family).

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#cached_html ⇒ `String`

As in ‘cached` but with tags.

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#cached_misspelling ⇒ `Boolean`

if the name is a misspelling, stores True.

Returns:

(Boolean)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#cached_original_combination ⇒ `String`

Returns name as formed in original combination, no author/year, without HTML.

Returns:

(String) —

name as formed in original combination, no author/year, without HTML

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#cached_original_combination_html ⇒ `String`

Returns as cached_original_combination but with HTML.

Returns:

(String) —

as cached_original_combination but with HTML

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#cached_primary_homonym ⇒ `String`

original genus and species name. Used to find and validate primary homonyms.

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#cached_primary_homonym_alternative_spelling ⇒ `String`

Original genus and species name in alternative spelling. Used to find and validate primary homonyms.

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#cached_secondary_homonym ⇒ `String`

current genus and species name. Used to find and validate secondary homonyms.

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#cached_secondary_homonym_alternative_spelling ⇒ `String`

Current genus and species name in alternative spelling. Used to find and validate secondary homonyms.

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#etymology ⇒ `String`

the derivation and history of the name in written form

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#feminine_name ⇒ `String`

Species name which are adjective or participle change depending on the gender of the genus. 3 fields provide alternative species spelling. The part_of_speech is designated as a taxon_name_classification. The gender of a genus also designated as a taxon_name_classification.

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#masculine_name ⇒ `String`

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#name ⇒ `String`^?

the fully latinized string (monominal) of a code governed taxonomic biological name not applicable for Combinations, they are derived from their pieces

Returns:

(String, nil)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#neuter_name ⇒ `String`

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#no_cached ⇒ `Boolean`

Returns When true cached values are not built.

Returns:

(Boolean) —

When true cached values are not built



199
200
201

# File 'app/models/taxon_name.rb', line 199

def no_cached
  @no_cached
end

#parent_id ⇒ `Integer`

The id of the parent taxon. The parent child relationship is exclusively organizational. All statuses and relationships of a taxon name must be explicitly defined via taxon name relationships or classifications. The parent of a taxon name can be thought of as “the place where you’d find this name in a hierarchy if you knew literally nothing else about that name.” In practice read each monominal in the name (protonym or combination) from right to left, the parent is the parent of the last monominal read. There are 3 simple rules for determining the parent of a Protonym or Combination:

1) the parent must always be at least one rank higher than the target names rank
2) the parent of a synonym (any sense) is the parent of the synonym's valid name
3) the parent of a combination is the parent of the highest ranked monominal in the epithet (almost always the parent of the genus)

Returns:

(Integer)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#project_id ⇒ `Integer`

the project ID

Returns:

(Integer)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#rank_class ⇒ `NomenclaturalRank class`

Returns rank as a NomenclaturalRank class, like NomenclaturalRank::Iczn::SpeciesGroup::Species.

Returns:

(NomenclaturalRank class) —

rank as a NomenclaturalRank class, like NomenclaturalRank::Iczn::SpeciesGroup::Species

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#taxonomy(rebuild = false) ⇒ `Object` (readonly)

See attr_reader.



191
192
193

# File 'app/models/taxon_name.rb', line 191

def taxonomy
  @taxonomy
end

#type ⇒ `String`

The subclass of this taxon name, e.g. Protonym or Combination

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#verbatim_author ⇒ `String`

the verbatim author string as provided ? is not post-filled in when Source is referenced !?

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#verbatim_name ⇒ `String`

a representation of what the Combination (fully spelled out) or Protonym (monominal) *looked like* in its originating publication. The sole purpose of this string is to represent visual differences from what is recorded in the latinized version of the name (Protonym#name, Combination#cached) from what was originally transcribed. This string should NOT include the author year (see verbatim_author and year_of_publication for those data).

If at all possible this field SHOULD NOT be used, it has very little downstream inference use.

If a subgenus it should __TODO____ (not?) contain parens.

Returns:

(String)

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

#year_of_publication ⇒ `Integer`

Returns sensu ICZN - the 4 digit year when this name was published, i.e. made available. Not the publishers date stamped on the title page, but the actual date of publication. Precidence for taxon name publication year is TaxonName#year_of_publication, Source#year, Source#stated_year.

Returns:

(Integer) —

sensu ICZN - the 4 digit year when this name was published, i.e. made available. Not the publishers date stamped on the title page, but the actual date of publication. Precidence for taxon name publication year is TaxonName#year_of_publication, Source#year, Source#stated_year.

# File 'app/models/taxon_name.rb', line 137

class TaxonName < ApplicationRecord

# @return class
#   this method calls Module#module_parent
# TODO: This method can be placed elsewhere inside this class (or even removed if not used)
#       when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.
def self.parent
  self.module_parent
end

# Must be before various of these includes, in particular MatrixHooks
has_closure_tree

include Housekeeping
include Shared::DataAttributes
include Shared::Tags
include Shared::Identifiers
include Shared::Notes
include Shared::Depictions
include Shared::Citations
include Shared::Confidences
include Shared::AlternateValues
include Shared::HasPapertrail
include Shared::Labels
include SoftValidation
include Shared::IsData
include TaxonName::OtuSyncronization

include Shared::MatrixHooks::Member
include Shared::MatrixHooks::Dynamic

include TaxonName::MatrixHooks

# Allows users to provide arbitrary annotations that "over-ride" rank string
ALTERNATE_VALUES_FOR = [:rank_class].freeze # !! Don't even think about putting this on `name`

COMBINATION_ELEMENTS = [:genus, :subgenus, :species, :subspecies, :variety, :subvariety, :form, :subform].freeze

SPECIES_EPITHET_RANKS = %w{species subspecies variety subvariety form subform}.freeze

NOT_LATIN = Regexp.new(/[^a-zA-Z|\-]/).freeze # Dash is allowed?

NO_CACHED_MESSAGE = 'REBUILD PROJECT TAXON NAME CACHE'.freeze

NOMEN_VALID = {
  icn: 'http://purl.obolibrary.org/obo/NOMEN_0000383',
  icnp: 'http://purl.obolibrary.org/obo/NOMEN_0000081',
  icvcn: 'http://purl.obolibrary.org/obo/NOMEN_0000125',
  iczn: 'http://purl.obolibrary.org/obo/NOMEN_0000224'
}.freeze

# See related concept in concerns/shared/taxonomy, this may belong there.
#
# @return [Hash]
attr_reader :taxonomy

# @return [Boolean]
#   When true, also creates an OTU that is tied to this taxon name
attr_accessor :also_create_otu

# @return [Boolean]
#   When true cached values are not built
attr_accessor :no_cached
delegate :nomenclatural_code, to: :rank_class, allow_nil: true
delegate :rank_name, to: :rank_class, allow_nil: true

# TODO: this was not implemented and tested properly
# I think the intent is *before* save, i.e. the name will change
# to a new cached value, so let's record the old one
#  after_save :create_new_combination_if_absent

after_save :set_cached, unless: Proc.new {|n| n.no_cached || errors.any? }
after_save :set_cached_warnings, if: Proc.new {|n| n.no_cached }
after_create :create_otu, if: :also_create_otu
before_destroy :check_for_children, prepend: true

validate :validate_rank_class_class,
  # :check_format_of_name,
  :validate_parent_from_the_same_project,
  :validate_parent_is_set,
  :check_new_rank_class,
  :check_new_parent_class,
  :validate_source_type,
  :validate_one_root_per_project

# TODO: remove, this is handled natively
validates_presence_of :type, message: 'is not specified'

validates :year_of_publication, date_year: {min_year: 1000, max_year: Time.now.year + 5}, allow_nil: true

# TODO: move some of these down to Protonym when they don't apply to Combination

# TODO: think of a different name, and test
has_many :historical_taxon_names, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_many :observation_matrix_row_items, as: :observation_object, inverse_of: :observation_object, class_name: 'ObservationMatrixRowItem::Dynamic::TaxonName', dependent: :destroy # was delete_all
has_many :observation_matrices, through: :observation_matrix_row_items

# TODO: revisit?
belongs_to :valid_taxon_name, class_name: 'TaxonName', foreign_key: :cached_valid_taxon_name_id

has_one :source_classified_as_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::SourceClassifiedAs'})
}, class_name: 'TaxonNameRelationship::SourceClassifiedAs', foreign_key: :subject_taxon_name_id

has_one :family_group_name_form_relationship, -> {
  where(taxon_name_relationships: {type: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm'})
}, class_name: 'TaxonNameRelationship::Iczn::Invalidating::Usage::FamilyGroupNameForm', foreign_key: :subject_taxon_name_id, inverse_of: :subject_taxon_name

has_one :source_classified_as, through: :source_classified_as_relationship, source: :object_taxon_name

has_many :otus, inverse_of: :taxon_name, dependent: :restrict_with_error
has_many :taxon_determinations, through: :otus
has_many :collection_objects, through: :taxon_determinations, source: :biological_collection_object
has_many :related_taxon_name_relationships, class_name: 'TaxonNameRelationship', foreign_key: :object_taxon_name_id, dependent: :restrict_with_error, inverse_of: :object_taxon_name

has_many :taxon_name_author_roles, class_name: 'TaxonNameAuthor', as: :role_object, dependent: :destroy, inverse_of: :role_object
has_many :taxon_name_authors, -> { order('roles.position ASC') }, through: :taxon_name_author_roles, source: :person

# TODO: Combinations shouldn't have classifications or relationships?  Move to Protonym?
has_many :taxon_name_classifications, dependent: :destroy, inverse_of: :taxon_name
has_many :taxon_name_relationships, foreign_key: :subject_taxon_name_id, dependent: :restrict_with_error, inverse_of: :subject_taxon_name


# NOTE: Protonym subclassed methods might not be nicely tracked here, we'll have to see.  Placement is after has_many relationships. (?)
accepts_nested_attributes_for :related_taxon_name_relationships, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank? || attributes['subject_taxon_name_id'].blank? }
accepts_nested_attributes_for :family_group_name_form_relationship, allow_destroy: true, reject_if: proc { |attributes| attributes['object_taxon_name_id'].blank? }
accepts_nested_attributes_for :taxon_name_authors, :taxon_name_author_roles, allow_destroy: true
accepts_nested_attributes_for :taxon_name_classifications, allow_destroy: true, reject_if: proc { |attributes| attributes['type'].blank?  }

has_many :classified_as_unavailable_or_invalid, -> { where type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID }, class_name: 'TaxonNameClassification'

# Combinations are rankless, but we need this scope here for generic returns
scope :order_by_rank, -> (code) {order(Arel.sql("position(taxon_names.rank_class in '#{code}')"))}

scope :with_same_cached_valid_id, -> { where(arel_table[:id].eq(arel_table[:cached_valid_taxon_name_id])) }
scope :with_different_cached_valid_id, -> { where(arel_table[:id].not_eq(arel_table[:cached_valid_taxon_name_id])) } # This doesn't catch all invalid names.  Those with classifications only are missed !$#!@#

scope :that_is_valid, -> {where(cached_is_valid: true) }
scope :that_is_invalid, -> {where(cached_is_valid: false) }

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

scope :with_type, -> (type) {where(type:)}
scope :descendants_of, -> (taxon_name) { with_ancestor(taxon_name )}

scope :ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
    .where('taxon_name_hierarchies.ancestor_id != ?', taxon_name.id)
    .order('taxon_name_hierarchies.generations DESC') # root is at index 0
}

# LEAVE UNORDERED, if you want order:
#   .order('taxon_name_hierarchies.generations DESC')
scope :self_and_ancestors_of, -> (taxon_name) {
  joins(:descendant_hierarchies)
    .where(taxon_name_hierarchies: {descendant_id: taxon_name.id})
}

# Includes taxon_name, doesn't order result
scope :ancestors_and_descendants_of, -> (taxon_name) do
  scoping do
    a = TaxonName.self_and_ancestors_of(taxon_name)
    b = TaxonName.descendants_of(taxon_name)
    TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
  end
end

# TODO: remove
scope :with_rank_class, -> (rank_class_name) { where(rank_class: rank_class_name) }

# TODO: remove
scope :with_parent_taxon_name, -> (parent) { where(parent_id: parent) }

scope :with_base_of_rank_class, -> (rank_class) { where('rank_class LIKE ?', "#{rank_class}%") }
scope :with_rank_class_including, -> (include_string) { where('rank_class LIKE ?', "%#{include_string}%") }
scope :project_root, -> (root_id) {where("(taxon_names.rank_class = 'NomenclaturalRank' AND taxon_names.project_id = ?)", root_id)}

# A specific relationship
scope :as_subject_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_subject_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT LIKE ?) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_without_taxon_name_relationship_array, -> (taxon_name_relationship_name_array) { includes(:taxon_name_relationships).where('(taxon_name_relationships.type NOT IN (?)) OR (taxon_name_relationships.subject_taxon_name_id IS NULL)', "#{taxon_name_relationship_name_array}%").references(:taxon_name_relationships) }
scope :as_subject_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {type: taxon_name_relationship}) }
scope :as_object_with_taxon_name_relationship_base, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }
scope :as_object_with_taxon_name_relationship_containing, -> (taxon_name_relationship) { includes(:related_taxon_name_relationships).where('taxon_name_relationships.type LIKE ?', "%#{taxon_name_relationship}%").references(:related_taxon_name_relationships) }

# @param relationship [Array, String]
def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

scope :with_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NOT NULL OR tnr2.object_taxon_name_id IS NOT NULL')
}
# *Any* relationship where there IS a relationship for a subject/object/both
scope :with_taxon_name_relationships_as_subject, -> { joins(:taxon_name_relationships) }
scope :with_taxon_name_relationships_as_object, -> { joins(:related_taxon_name_relationships) }

# *Any* relationship where there is NOT a relationship for a subject/object/both
scope :without_subject_taxon_name_relationships, -> { includes(:taxon_name_relationships).where(taxon_name_relationships: {subject_taxon_name_id: nil}) }
scope :without_object_taxon_name_relationships, -> { includes(:related_taxon_name_relationships).where(taxon_name_relationships: {object_taxon_name_id: nil}) }

scope :without_taxon_name_relationships, -> {
  joins('LEFT OUTER JOIN taxon_name_relationships tnr1 ON taxon_names.id = tnr1.subject_taxon_name_id').
  joins('LEFT OUTER JOIN taxon_name_relationships tnr2 ON taxon_names.id = tnr2.object_taxon_name_id').
  where('tnr1.subject_taxon_name_id IS NULL AND tnr2.object_taxon_name_id IS NULL')
}

# TODO: deprecate all of these for where()
scope :with_parent_id, -> (parent_id) {where(parent_id:)}
scope :with_cached_valid_taxon_name_id, -> (cached_valid_taxon_name_id) {where(cached_valid_taxon_name_id:)}
scope :with_cached_original_combination, -> (original_combination) { where(cached_original_combination: original_combination) }

scope :without_otus, -> { includes(:otus).where(otus: {id: nil}) }
scope :with_otus, -> { includes(:otus).where.not(otus: {id: nil}) }

# @return [Scope]
#   Combinations that are composed of children of this taxon name
#     when those children are not currently descendants of this taxon name
#
# !! When :cached_valid_taxon_name_id is properly set then this method is not required
# rather you should use :historical_taxon_names.
#
def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

# @return Scope
#   names that are not leaves
# TODO: belongs in lib/queries/filter.rb likely
def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

soft_validate(:sv_missing_confidence_level,
              set: :missing_fields,
              name: 'Missing confidence level',
              description: 'To remaind that the taxon spelling have to be compared to the original source' )

soft_validate(:sv_missing_original_publication,
              set: :missing_fields,
              name: 'Missing original source',
              description: 'Original source is not selected' )

=begin
soft_validate(:sv_missing_author,
              set: :missing_fields,
              name: 'Missing author')

soft_validate(:sv_missing_year,
              set: :missing_fields,
              name: 'Missing year')
=end

soft_validate(
  :sv_parent_is_valid_name,
  set: :parent_is_valid_name,
  fix: :sv_fix_parent_is_valid_name,
  name: 'Parent should be a valid taxon',
  description: 'When the parent taxon (for example a genus) is treated as a synonym, all subordinate taxa from this taxon should be transferred to the valid taxon' )

soft_validate(
  :sv_conflicting_subordinate_taxa,
  set: :parent_is_valid_name,
  name: 'Conflicting subordinate taxa',
  description: 'Unavailable or invalid taxon should not have subordinate taxa' )

soft_validate(
  :sv_cached_names,
  set: :cached_names,
  fix: :sv_fix_cached_names,
  name: 'Cached names',
  description: 'Check if cached values need to be updated' )

# TODO: move to protonym spec?
soft_validate(
  :sv_not_synonym_of_self,
  set: :not_synonym_of_self,
  name: 'Not synonym of self',
  description: 'Taxon has two conflicting relationships (invalidating and validating).' )

# TODO: move to protonym spec?
soft_validate(
  :sv_two_unresolved_alternative_synonyms,
  set: :two_unresolved_alternative_synonyms,
  name: 'Two conflicting relationships',
  description: 'Taxon has two conflicting relationships.' )

# TODO: move to combination spec?
soft_validate(
  :sv_incomplete_combination,
  set: :incomplete_combination,
  name: 'Incomplete combination',
  description: 'Intermediate ranks are missing in combination (either original or subsequent)' )

# @return [Array of TaxonName]
#   ordered by rank, a scope-like hack
def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

# TODO: what is this:!? :)
def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

# See attr_reader.
def taxonomy(rebuild = false)
  if rebuild
    @taxonomy = full_name_hash
  else
    @taxonomy ||= full_name_hash
  end
end

# @return [Scope] Protonym(s) the **broad sense** synonyms of this name
def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

# @return [String]
#   rank as human readable short-form, like 'genus' or 'species'
def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

# @return [String]
#   rank (Kindom, Phylum...) as a string, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_string
  read_attribute(:rank_class)
end

def rank_class=(value)
  write_attribute(:rank_class, value.to_s)
end

# @return [NomenclaturalRank class]
#   rank as a {NomenclaturalRank} class, like {NomenclaturalRank::Iczn::SpeciesGroup::Species}
def rank_class
  r = read_attribute(:rank_class)
  Ranks.valid?(r) ? r.safe_constantize : r
end

# @see .out_of_scope_combinations
def out_of_scope_combinations
  ::TaxonName
    .where(project_id:)
    .out_of_scope_combinations(id)
end

# @return [TaxonName, nil] an ancestor at the specified rank
# @param rank [symbol|string|
#   like :species or 'genus'
# @param include_self [Boolean]
#   if true then self will also be returned
def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

# @return scope [TaxonName, nil] an ancestor at the specified rank
# @params rank [symbol|string|
#   like :species or 'genus'
def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

# @return [Array]
#   all TaxonNameRelationships where this taxon is an object or subject.
def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

# @return [Array of TaxonName]
#   all taxon_names which have relationships to this taxon as an object or subject.
def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

# @return [String, nil]
#   the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.
# Important, string format priority is
#   1) as provided verbatim
#   2) as generated from People
#   3) as taken from the Source
#       Source People (Authors)
#       Source Verbatim authors
def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

# @return [Integer]
#   a 4 digit integer representing year of publication, like 1974
def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

# @return Year,nil
#  based on TaxonNameRelationships only at present
def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

# TODO: cleanly isolate getters, setters, and cached builders
# TODO: remove, this is only used for a strange call in sv_checked cached.
#
# @return String, nil
#   virtual attribute, to ultimately be fixed in db
def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

# @return [Time]
#   effective date of publication, used to determine nomenclatural priority
#
# !! Overrides *and* references Shared::Citations#nomenclature_date
def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

# @return [array]
# returns array of hashes for history of taxon. Could be used for catalogue construction.  Probably belongs in catatlog.
def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

# @return [Class, nil]
#   gender of a genus as class
def gender_class
  gender_instance.try(:type_class)
end

# @return [TaxonNameClassification instance, nil]
#    the gender classification of this name, if provided
def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

# @return [String, nil]
#    gender as a string (only applicable to Genera)
def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

# @return [Class]
#   part of speech of a species as class.
def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

# @return [String]
#   part of speech of a species as string.
def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

# @return [Array of String]
#   the unique string labels (human readable) derived from TaxonNameClassifications
def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

# @return [Scope]
def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

# @return [Array of String]
#   the unique string labels derived from and TaxonNameRelationships
def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

# @return [Array of String]
#   the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships
def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

# @return [Array of Protonym]
#   All of the names this name has been in combination with
def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

# @return [Array of Protonym]
#   for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)
def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end


# TODO: should be moved to helpers
# and referenced in models with helper.

# TODO: in refactor these are often just helper methods ,
# though variously used in soft_validations
# (and various are only used in helpers already)

# @return [String]
#   combination of cached_html and cached_author_year.
def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

# @return [String]
#   combination of cached_original_combination_html and original_author_year.
def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

# @return [String] combination of cached and cached_author_year.
def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

# @return [String, nil]
#   derived from cached_author_year
#   !! DO NOT USE IN building cached !!
#   See also app/helpers/taxon_names_helper
def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

# @return [Array of TaxonName] ancestors of type 'Protonym'
def ancestor_protonyms
  Protonym.ancestors_of(self)
end

# @return [Array of TaxonName] descendants of type 'Protonym'
def descendant_protonyms
  Protonym.descendants_of(self)
end

# @return [Boolean]
#   true if there is a relationship where then name is asserted to be invalid
def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

# @return [Boolean]
#  true if this name has any classification asserting that it is valid
def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is NOT valid or that it is unavailable
def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

# @return [Boolean]
#  whether this name has any classification asserting that this the name is unavailable
def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#  @return [Boolean]
#     return true if name is unavailable OR invalid, else false, checks both classifications and relationships
# !! Should only be referenced when building cached values, all other uses should rather be `!is_valid?`
def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

# @return [Boolean]
#   after all inference on the validity of a name, the result is stored
#   in cached_valid_taxon_name_id, #is_valid checks that result
def is_valid?
  cached_is_valid
end

# Has Classification, but no relationship describing why
def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

# @return [Boolean]
#   whether this name needs italics applied
def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

def is_protonym?
  type == 'Protonym'
end

def is_combination?
  type == 'Combination'
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of Fossil
def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

# @return [Boolean]
#   true if this name has a TaxonNameClassification of hybrid
def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of candidatus
def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

# @return [True|False]
#   true if this name has a TaxonNameClassification of not_binominal
def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

# @return [Boolean]
#  see subclasses
def is_genus_or_species_rank?
  false
end

# @return [TaxonName]
#  a valid taxon_name for an invalid name or self for valid name.
#  a stub here - See Protonym and Combination
def get_valid_taxon_name
  nil
end

# @return [TaxonNameRelationship]
#  returns youngest taxon name relationship where self is the subject.
def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

# @return [TaxonName]
#    returns the youngest #object_taxon_name from the youngest taxon name relationship.
def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

# @return [Array of TaxonName]
#  returns list of invalid names for a given taxon.
# Can't we just use #valid_id now?
# DD: no this is used for validation of multiple conflicting relationships
# this list does not return combinations
def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

# @return [Array of Strings]
#   names of all genera where the species was placed
def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

# TODO: We need to isolate this into 2 subclasses,
# 1 - cached methods that touch author/year
# 2 - cached methods that do not
def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

# See TaxonNameAuthor
def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

def set_cached_author
  update_column(:cached_author, get_author)
end

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

# Stub, see subclasses
# TaxonNameRelationships call it for Combinations
def get_original_combination
  nil
end

# Stub, see subclasses
#   only Protonym, but TaxonNameRelationships call it for Combinations
def get_original_combination_html
  nil
end

# @return [Array]
#   of TaxonName
#   same as self.ancestors.to_a, but also works
#    for new records when parents specified
def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

# @return [Array of TaxonName]
#   an list of ancestors, Root first
# Uses parent recursion when record is new and awesome_nested_set_is_not_usable
def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

# @return [ rank, prefix, name], ...] for genus and below
# @taxon_name.full_name_array # =>
#   [ ["genus", [nil, "Aus"]],
#     ["subgenus", [nil, "Aus"]],
#  "section"=>["sect.", "Aus"], "series"=>["ser.", "Aus"], "species"=>[nil, "aaa"], "subspecies"=>[nil, "bbb"], "variety"=>["var.", "ccc"]\}
def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

# @return Hash
#  { 'family' => 'Aidae', ...}
def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

# !! TODO: when name is a subgenus will not grab genus
# !! TODO: Higher classification does not follow the same pattern
# ?? TODO: Replace with `taxonomy` object .to_h?
#
# @!return [ { rank => [prefix, name] }
#   Returns a hash of rank => [prefix, name] for genus and below
# @taxon_name.full_name_hash # =>
#      { "family' => 'Gidae',
#        "genus" => [nil, "Aus"],
#        "subgenus" => [nil, "Aus"],
#        "section" => ["sect.", "Aus"],
#        "series" => ["ser.", "Aus"],
#        "species" => [nil, "aaa"],
#        "subspecies" => [nil, "bbb"],
#        "variety" => ["var.", "ccc"]}
def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

# @return [String, nil]
#  A monominal if names is above genus, or a full epithet if below.
#  Does not include author_year. Does not include HTML.
def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

# @return String
def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

# @return [String]
#    TODO: does this form of the name contain parens for subgenus?
#    TODO: provide a default to gender (but do NOT eliminate param)
#    TODO: on third thought- eliminate this mess
def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

# @return [String, nil]
def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

# return [String, nil, false] # TODO: fix
def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

# return [Boolean]
#   whether there is an ICZN missapplication relationship present on this name
def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

# return [String]
#   the author and year of the name, adds parenthesis where asserted
def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

# @return [String, nil]
#   the authors, and year, with parentheses as inferred by the data
def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

# @return Protonym
def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

# @return [String, nil]
def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

# @return [Boolean]
def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

# TODO: this should be paginated, not all IDs!
def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

# TODO: this should be paginated, not all IDs!
def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

# @return [Scope]
#   All taxon names attached to relationships recently created by user
def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

# @return [Array]
def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

# @return [Hash]
def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

# See Shared::MatrixHooks
# @return [{"matrix_row_item": matrix_column_item, "object": object}, false]
# the hash corresponding to the keyword used in this tag if it exists
# !! Assumes it can only be in one matrix, this is wrong !!
def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

# @return [String]
#  a reified ID is used when the original combination, which does not yet have it's own ID, is not the same as the current classification
# Some observations:
#  - reified ids are only for original combinations (for which we have no ID)
#  - reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change
# Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.)
# Duplicated in COLDP export code
def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

protected

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

# TODO: move to Protonym when we eliminate TaxonName.new()
def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

# See subclasses
def validate_rank_class_class
  true
end

# Note- prior version prevented groups from moving when set in error, and was far too strict
def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

# TODO: this needs to go.
def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

# def sv_missing_author
#   true # see Protonym
# end
#
# def sv_missing_year
#   true # see Protonym
# end

def sv_missing_etymology
  true # see Protonym
end

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

# TODO: This can be made more specific, we don't need to call some of the methods in set_cached
# It also should never be required.
def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#  Required for synonyms of synomyms
def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

def sv_cached_names
  true # see validation in subclasses
end

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

def sv_missing_relationships
  true # see validation in Protonym.rb
end

def sv_validate_name
  true # see validation in Protonym.rb
end

def sv_missing_classifications
  true # see validation in Protonym.rb
end

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

def sv_primary_types
  true # see validation in Protonym.rb
end

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

def sv_type_placement
  true # see validation in Protonym.rb
end

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

def sv_parent_priority
  true # see validation in Protonym.rb
end

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

def sv_combination_duplicates
  true # see validation in Combination.rb
end

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

end

Class Method Details

.calculated_invalid ⇒ `Object`

# File 'app/models/taxon_name.rb', line 278

def self.calculated_invalid
  a = TaxonName.with_different_cached_valid_id # that_is_invalid
  b = TaxonName.joins(:taxon_name_classifications).where(taxon_name_classifications: {type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID })
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

.calculated_valid ⇒ `Object`

# File 'app/models/taxon_name.rb', line 284

def self.calculated_valid
  # Alt format: TaxonName.that_is_valid.left_joins(:classified_as_unavailable_or_invalid).merge(TaxonNameClassification.where(id: nil))
  TaxonName
    .with_same_cached_valid_id
    .where.not(
      id: TaxonNameClassification.select(:taxon_name_id).where(type: TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID)
    )
end

.foo(rank_classes) ⇒ `Object`

TODO: what is this:!? :)

# File 'app/models/taxon_name.rb', line 507

def self.foo(rank_classes)
  from <<-SQL.strip_heredoc
    ( SELECT *, rank()
         OVER (
             PARTITION BY rank_class, parent_id
             ORDER BY generations asc, name
          ) AS rn
       FROM taxon_names
       INNER JOIN "taxon_name_hierarchies" ON "taxon_names"."id" = "taxon_name_hierarchies"."descendant_id"
       WHERE #{rank_classes.collect{|c| "rank_class = '#{c}'" }.join(' OR ')}
       ) as taxon_names
  SQL
end

.not_leaves ⇒ `Object`

TODO: belongs in lib/queries/filter.rb likely

Returns:

Scope names that are not leaves

# File 'app/models/taxon_name.rb', line 415

def self.not_leaves
  t = self.arel_table
  h = ::TaxonNameHierarchy.arel_table

  a = t.alias('a_')
  b = t.project(a[Arel.star]).from(a)

  c = h.alias('h1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:ancestor_id])
    )

  e = c[:generations].not_eq(0)
  f = c[:ancestor_id].not_eq(c[:descendant_id])

  b = b.where(e.and(f))
  b = b.group(a[:id])
  b = b.as('tnh_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(t['id']))))
end

.out_of_scope_combinations(taxon_name_id) ⇒ `Scope`

!! When :cached_valid_taxon_name_id is properly set then this method is not required rather you should use :historical_taxon_names.

Returns:

(Scope) —
Combinations that are composed of children of this taxon name
```
when those children are not currently descendants of this taxon name
```

# File 'app/models/taxon_name.rb', line 381

def self.out_of_scope_combinations(taxon_name_id)
  t = ::TaxonName.arel_table
  h = ::TaxonNameHierarchy.arel_table
  r = ::TaxonNameRelationship.arel_table

  h1 = h.alias('osch_')
  h2 = h.alias('oschh_')

  b = h.project(
    h1[:descendant_id].as('b'),
    h2[:ancestor_id].as('c'),
  ).from([h])

  b = b.join(r, Arel::Nodes::InnerJoin).on(h[:descendant_id].eq(r[:subject_taxon_name_id]).and(h[:ancestor_id].eq(taxon_name_id)))
    .join(h1, Arel::Nodes::InnerJoin).on(r[:object_taxon_name_id].eq(h1[:descendant_id]).and(h1[:ancestor_id].not_eq(h1[:descendant_id])))
    .join(h2, Arel::Nodes::OuterJoin).on(
      h1[:ancestor_id].eq(h2[:ancestor_id]).
      and(h2[:descendant_id].eq(taxon_name_id))
    )

  # This was particularly useful in debugging the join chain:
  # ap TaxonNameHierarchy.connection.execute(b.to_sql).collect{|a| a}

  b = b.as('abc')

  ::Combination
    .joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['b'].eq(t[:id]))))
    .where(b['c'].eq(nil))
    .distinct
end

.parent ⇒ `Object`

TODO: This method can be placed elsewhere inside this class (or even removed if not used)

when https://github.com/ClosureTree/closure_tree/issues/346 is fixed.

Returns:

class this method calls Module#module_parent



143
144
145

# File 'app/models/taxon_name.rb', line 143

def self.parent
  self.module_parent
end

.select_optimized(user_id, project_id, target: nil) ⇒ `Hash`

Returns:

(Hash)

# File 'app/models/taxon_name.rb', line 1566

def self.select_optimized(user_id, project_id, target: nil)
  klass = (target == 'TypeMaterial' ? Protonym : TaxonName)
  h = {
    recent: klass.used_recently(user_id, project_id, target: klass.name),
    pinboard: klass.pinned_by(user_id).pinned_in_project(project_id).to_a
  }

  h[:quick] = (klass.pinned_by(user_id).pinboard_inserted.pinned_in_project(project_id).to_a + h[:recent][0..3]).uniq
  h
end

.sort_by_rank(taxon_names) ⇒ `Array of TaxonName`

Returns ordered by rank, a scope-like hack.

Returns:

(Array of TaxonName) —

ordered by rank, a scope-like hack



502
503
504

# File 'app/models/taxon_name.rb', line 502

def self.sort_by_rank(taxon_names)
  taxon_names.sort!{|a, b| RANKS.index(a.rank_string) <=> RANKS.index(b.rank_string)}
end

.used_recently(user_id, project_id, target: nil) ⇒ `Array`

Returns:

(Array)

# File 'app/models/taxon_name.rb', line 1548

def self.used_recently(user_id, project_id, target: nil)
  klass, a,b,c = nil, nil, nil, nil
  if target == 'TypeMaterial'
    klass = Protonym
    a = klass.is_species_group.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).is_species_group.where(type: klass.name).limit(6).to_a
  else
    klass = TaxonName
    a = klass.touched_by(user_id).where(project_id:).order(updated_at: :desc).limit(6).to_a
    b = used_recently_in_classifications(user_id, project_id).where(type: klass.name).limit(6).to_a
    c = used_recently_in_relationships(user_id, project_id).where(type: klass.name).limit(6).to_a
  end

  d = [ a,b,c ].flatten.compact.uniq.sort{|e,f| e.cached <=> f.cached}
end

.used_recently_in_classifications(user_id, project_id) ⇒ `Scope`

Returns All taxon names attached to relationships recently created by user.

Returns:

(Scope) —

All taxon names attached to relationships recently created by user

# File 'app/models/taxon_name.rb', line 1518

def self.used_recently_in_classifications(user_id, project_id)
  TaxonName.where(project_id:, updated_by_id: user_id)
    .joins(:taxon_name_classifications)
    .includes(:taxon_name_classifications)
    .where(taxon_name_classifications: { updated_at: 1.week.ago..Time.now } )
    .order('taxon_name_classifications.updated_at DESC')
end

.used_recently_in_relationships(user_id, project_id) ⇒ `Scope`

Returns All taxon names attached to relationships recently created by user.

Returns:

(Scope) —

All taxon names attached to relationships recently created by user

# File 'app/models/taxon_name.rb', line 1528

def self.used_recently_in_relationships(user_id, project_id)
  t = TaxonNameRelationship.arel_table
  t1 = t.alias('tnr1')
  t2 = t.alias('tnr2')

  sql = t1[:updated_by_id].eq(user_id).or(t1[:created_by_id].eq(user_id))
    .or(t2[:updated_by_id].eq(user_id).or(t2[:created_by_id].eq(user_id))
       ).to_sql

       sql2 = t1[:updated_at].between( 1.week.ago..Time.now )
         .or( t2[:updated_at].between( 1.week.ago..Time.now ) ).to_sql

       TaxonName.with_taxon_name_relationships
         .where(taxon_names: {project_id:})
         .where(sql2)
         .where(sql)
         .order('taxon_names.updated_at DESC') ## needs optimisation. Does not sort by TNR date
end

.with_taxon_name_relationship(relationship) ⇒ `Object`

Parameters:

relationship (Array, String)

# File 'app/models/taxon_name.rb', line 341

def self.with_taxon_name_relationship(relationship)
  a = TaxonName.joins(:taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  b = TaxonName.joins(:related_taxon_name_relationships).where(taxon_name_relationships: {type: relationship})
  TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

Instance Method Details

#all_taxon_name_relationships ⇒ `Array`

Returns all TaxonNameRelationships where this taxon is an object or subject.

Returns:

(Array) —

all TaxonNameRelationships where this taxon is an object or subject.

# File 'app/models/taxon_name.rb', line 593

def all_taxon_name_relationships
  # !! If self relationships are ever made possible this needs a DISTINCT clause
  TaxonNameRelationship.find_by_sql(
    "SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.subject_taxon_name_id = #{self.id}
     UNION
     SELECT taxon_name_relationships.*
       FROM taxon_name_relationships
       WHERE taxon_name_relationships.object_taxon_name_id = #{self.id}")
end

#ancestor_at_rank(rank, include_self = false) ⇒ `TaxonName`^?

Returns an ancestor at the specified rank.

Parameters:

rank (symbol|string| like :species or 'genus') —

ank [symbol|string| like :species or ‘genus’
include_self (Boolean) (defaults to: false) —

if true then self will also be returned

Returns:

(TaxonName, nil) —

an ancestor at the specified rank

# File 'app/models/taxon_name.rb', line 570

def ancestor_at_rank(rank, include_self = false)
  if target_code = (is_combination? ? combination_taxon_names.first.nomenclatural_code : nomenclatural_code)
    r = Ranks.lookup(target_code, rank)
    return self if include_self && (rank_class.to_s == r)
    ancestors.with_rank_class( r ).first
  else
    # Root has no nomenclature code
    return nil
  end
end

#ancestor_hash ⇒ `Object`

Returns Hash { ‘family’ => ‘Aidae’, …}.

Returns:

Hash { ‘family’ => ‘Aidae’, …}

# File 'app/models/taxon_name.rb', line 1201

def ancestor_hash
  h = {}
  safe_self_and_ancestors.each do |n|
    h[n.rank] = n.name
  end
  h
end

#ancestor_protonyms ⇒ `Array of TaxonName`

Returns ancestors of type ‘Protonym’.

Returns:

(Array of TaxonName) —

ancestors of type ‘Protonym’



851
852
853

# File 'app/models/taxon_name.rb', line 851

def ancestor_protonyms
  Protonym.ancestors_of(self)
end

#ancestors_through_parents(result = [self], start = self) ⇒ `Array`

Returns of TaxonName same as self.ancestors.to_a, but also works

for new records when parents specified.

Returns:

(Array) —
of TaxonName same as self.ancestors.to_a, but also works
```
for new records when parents specified
```

# File 'app/models/taxon_name.rb', line 1154

def ancestors_through_parents(result = [self], start = self)
  if start.parent.nil?
    return result.reverse
  elsif result.include?(start.parent)
    raise  TaxonWorks::Error, 'parents contain infinfinte loop'
  else
    result << start.parent
    ancestors_through_parents(result, start.parent)
  end
end

#author_string ⇒ `String`^?

Important, string format priority is

1) as provided verbatim
2) as generated from People
3) as taken from the Source
    Source People (Authors)
    Source Verbatim authors

Returns:

(String, nil) —

the baseline means of displaying name authorship, i.e. the author for this taxon, last name only.

# File 'app/models/taxon_name.rb', line 623

def author_string
  return verbatim_author if !verbatim_author.nil?
  if taxon_name_authors.any?
    return Utilities::Strings.authorship_sentence( taxon_name_authors.pluck(:last_name) )
    #return Utilities::Strings.authorship_sentence( taxon_name_authors.collect{|a| [a.prefix, a.last_name, a.suffix].compact.join(' ')} )
  end

  return source.authority_name if !source.nil?
  nil
end

#cached_html_name_and_author_year ⇒ `String`

Returns combination of cached_html and cached_author_year.

Returns:

(String) —

combination of cached_html and cached_author_year.



817
818
819

# File 'app/models/taxon_name.rb', line 817

def cached_html_name_and_author_year
  [cached_html, cached_author_year].compact.join(' ')
end

#cached_html_original_name_and_author_year ⇒ `String`

Returns combination of cached_original_combination_html and original_author_year.

Returns:

(String) —

combination of cached_original_combination_html and original_author_year.



823
824
825

# File 'app/models/taxon_name.rb', line 823

def cached_html_original_name_and_author_year
  [cached_original_combination_html, original_author_year].compact.join(' ')
end

#cached_name_and_author_year ⇒ `String`

Returns combination of cached and cached_author_year.

Returns:

(String) —

combination of cached and cached_author_year.



828
829
830

# File 'app/models/taxon_name.rb', line 828

def cached_name_and_author_year
  [cached, cached_author_year].compact.join(' ')
end

#check_for_children ⇒ `Object` (protected)

# File 'app/models/taxon_name.rb', line 1635

def check_for_children
  if leaf?
    true
  else
    errors.add(:base, 'This taxon has children names attached, delete those first.')
    throw :abort
  end
end

#check_new_parent_class ⇒ `Object` (protected)

TODO: move to Protonym when we eliminate TaxonName.new()

# File 'app/models/taxon_name.rb', line 1665

def check_new_parent_class
  if is_protonym? && parent_id != parent_id_was && !parent_id_was.nil? && nomenclatural_code == :iczn
    if old_parent = TaxonName.find_by(id: parent_id_was)
      if (rank_name == 'subgenus' || rank_name == 'subspecies') && old_parent.name == name
        errors.add(:parent_id, "The nominotypical #{rank_name} #{name} can not be moved out of the nominal #{old_parent.rank_name}")
      end
    end
  end
end

#check_new_rank_class ⇒ `Object` (protected)

Note- prior version prevented groups from moving when set in error, and was far too strict

# File 'app/models/taxon_name.rb', line 1681

def check_new_rank_class
  if (rank_class != rank_class_was) && !rank_class_was.nil?

    if rank_class_was == 'NomenclaturalRank' && rank_class_changed?
      errors.add(:rank_class, 'Root can not have a new rank')
      return
    end
  end
end

#classification_invalid_or_unavailable? ⇒ `Boolean`

Returns whether this name has any classification asserting that this the name is NOT valid or that it is unavailable.

Returns:

(Boolean) —

whether this name has any classification asserting that this the name is NOT valid or that it is unavailable



874
875
876

# File 'app/models/taxon_name.rb', line 874

def classification_invalid_or_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).any?
end

#classification_unavailable? ⇒ `Boolean`

Returns whether this name has any classification asserting that this the name is unavailable.

Returns:

(Boolean) —

whether this name has any classification asserting that this the name is unavailable



880
881
882

# File 'app/models/taxon_name.rb', line 880

def classification_unavailable?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE).any?
end

#classification_valid? ⇒ `Boolean`

Returns true if this name has any classification asserting that it is valid.

Returns:

(Boolean) —

true if this name has any classification asserting that it is valid



868
869
870

# File 'app/models/taxon_name.rb', line 868

def classification_valid?
  taxon_name_classifications.with_type_array(TAXON_NAME_CLASS_NAMES_VALID).any? # !TaxonNameClassification.where_taxon_name(self).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
end

#clear_cached(update: false) ⇒ `Object`

# File 'app/models/taxon_name.rb', line 1032

def clear_cached(update: false)
  assign_attributes(
    cached_html: nil,
    cached_author_year: nil,
    cached_author: nil,
    cached_original_combination_html: nil,
    cached_secondary_homonym: nil,
    cached_primary_homonym: nil,
    cached_secondary_homonym_alternative_spelling: nil,
    cached_primary_homonym_alternative_spelling: nil,
    cached_misspelling: nil,
    cached_classified_as: nil,
    cached: nil,
    cached_valid_taxon_name_id: nil,
    cached_is_valid: nil,
    cached_original_combination: nil,
    cached_nomenclature_date: nil
  )
  save if update
end

#combination_list_all ⇒ `Array of Protonym`

Returns All of the names this name has been in combination with.

Returns:

(Array of Protonym) —

All of the names this name has been in combination with



797
798
799

# File 'app/models/taxon_name.rb', line 797

def combination_list_all
  taxon_name_relationships.with_type_base('TaxonNameRelationship::Combination').collect {|r| r.object_taxon_name}.uniq
end

#combination_list_self ⇒ `Array of Protonym`

Returns for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?).

Returns:

(Array of Protonym) —

for all names this name has been in combination with, select those names that are of the same rank (!! CONFIRM?)



803
804
805

# File 'app/models/taxon_name.rb', line 803

def combination_list_self
  combination_list_all.select{|c| c.protonyms_by_rank[c.protonyms_by_rank.keys.last] == self}
end

#combined_statuses ⇒ `Array of String`

Returns the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships.

Returns:

(Array of String) —

the unique string labels derived from both TaxonNameClassifications and TaxonNameRelationships



791
792
793

# File 'app/models/taxon_name.rb', line 791

def combined_statuses
  (statuses_from_classifications + statuses_from_relationships).uniq.sort
end

#create_otu ⇒ `Object`



1512
1513
1514

# File 'app/models/taxon_name.rb', line 1512

def create_otu
  Otu.create(by: creator, project_id:, taxon_name_id: id)
end

#descendant_protonyms ⇒ `Array of TaxonName`

Returns descendants of type ‘Protonym’.

Returns:

(Array of TaxonName) —

descendants of type ‘Protonym’



856
857
858

# File 'app/models/taxon_name.rb', line 856

def descendant_protonyms
  Protonym.descendants_of(self)
end

#descendants_at_rank(rank) ⇒ `Object`

# File 'app/models/taxon_name.rb', line 584

def descendants_at_rank(rank)
  return TaxonName.none if nomenclatural_code.blank? # Root names
  descendants.with_rank_class(
    Ranks.lookup(nomenclatural_code, rank)
  )
end

#first_possible_invalid_taxan_name_relationship ⇒ `Object`



962
963
964

# File 'app/models/taxon_name.rb', line 962

def first_possible_invalid_taxan_name_relationship
  taxon_name_relationships.reload.with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_INVALID).youngest_by_citation
end

#first_possible_valid_taxon_name ⇒ `TaxonName`

Returns the youngest #object_taxon_name from the youngest taxon name relationship.

Returns:

(TaxonName) —

returns the youngest #object_taxon_name from the youngest taxon name relationship.

# File 'app/models/taxon_name.rb', line 968

def first_possible_valid_taxon_name
  return self if !unavailable_or_invalid?                      # catches all cases where no Classifications or Relationships are provided
  relationship = first_possible_valid_taxon_name_relationship
  relationship.nil? ? self : relationship.object_taxon_name    # ?! probably the if is caught by unavailable_or_invalid already
end

#first_possible_valid_taxon_name_relationship ⇒ `TaxonNameRelationship`

Returns youngest taxon name relationship where self is the subject.

Returns:

(TaxonNameRelationship) —

returns youngest taxon name relationship where self is the subject.



958
959
960

# File 'app/models/taxon_name.rb', line 958

def first_possible_valid_taxon_name_relationship
  taxon_name_relationships.reload.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).youngest_by_citation
end

#full_name_array ⇒ `rank`, ...

“section”=>[“sect.”, “Aus”], “series”=>[“ser.”, “Aus”], “species”=>[nil, “aaa”], “subspecies”=>[nil, “bbb”], “variety”=>[“var.”, “ccc”]}

Returns:

(rank, prefix, name) —

, …] for genus and below

# File 'app/models/taxon_name.rb', line 1187

def full_name_array
  gender = nil
  data = []
  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'
    method = "#{rank.gsub(/\s/, '_')}_name_elements"
    data.push([rank] + send(method, i, gender)) if self.respond_to?(method)
  end
  data
end

#full_name_hash ⇒ `Object`

!! TODO: when name is a subgenus will not grab genus !! TODO: Higher classification does not follow the same pattern ?? TODO: Replace with ‘taxonomy` object .to_h?

# File 'app/models/taxon_name.rb', line 1224

def full_name_hash
  gender = nil
  data = {}

  # !! TODO: create a persisted only version of this for speed
  # !! You can not use self.self_and_ancestors because (this) record is not saved off.

  safe_self_and_ancestors.each do |i|
    rank = i.rank
    gender = i.gender_name if rank == 'genus'

    if i.is_genus_or_species_rank?
      if ['genus', 'subgenus', 'species', 'subspecies'].include?(rank)
        data[rank] = [nil, i.name_with_misspelling(gender)]
      else
        data[rank] = [i.rank_class.abbreviation, i.name_with_misspelling(gender)]
      end
    else
      data[rank] = i.name
    end
  end

  # Only check for these ranks
  if COMBINATION_ELEMENTS.include?(rank.to_sym)
    if data['genus'].nil?
      if original_genus
        data['genus'] = [nil, "[#{original_genus&.name}]"]
      else
        data['genus'] = [nil, '[GENUS NOT SPECIFIED]']
      end
    end

    if data['species'].nil? && (!data['subspecies'].nil? || !data['variety'].nil? || !data['subvariety'].nil? || !data['form'].nil? || !data['subform'].nil?)
      data['species'] = [nil, '[SPECIES NOT SPECIFIED]']
    end

    if !data['subvariety'].nil? && data['variety'].nil?
      data['variety'] = [nil, '[VARIETY NOT SPECIFIED]']
    end

    if !data['subform'].nil? && data['form'].nil?
      data['form'] = [nil, '[FORM NOT SPECIFIED]']
    end
  end

  data
end

#gbif_status_array ⇒ `Object`

# File 'app/models/taxon_name.rb', line 1001

def gbif_status_array
  return nil if self.class.nil?
  return ['combination'] if self.class == 'Combination'
  s1 = taxon_name_classifications.collect{|c| c.class.gbif_status}.compact
  return s1 unless s1.empty?
  s2 = taxon_name_relationships.collect{|r| r.class.gbif_status_of_subject}
  s3 = related_taxon_name_relationships.collect{|r| r.class.gbif_status_of_object}

  s = s2 + s3
  s.compact!
  return ['valid'] if s.empty?
  s
end

#gender_class ⇒ `Class`^?

Returns gender of a genus as class.

Returns:

(Class, nil) —

gender of a genus as class



738
739
740

# File 'app/models/taxon_name.rb', line 738

def gender_class
  gender_instance.try(:type_class)
end

#gender_instance ⇒ `TaxonNameClassification instance`^?

Returns the gender classification of this name, if provided.

Returns:

(TaxonNameClassification instance, nil) —

the gender classification of this name, if provided



744
745
746

# File 'app/models/taxon_name.rb', line 744

def gender_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::Gender').first
end

#gender_name ⇒ `String`^?

Returns gender as a string (only applicable to Genera).

Returns:

(String, nil) —

gender as a string (only applicable to Genera)



750
751
752

# File 'app/models/taxon_name.rb', line 750

def gender_name
  gender_instance.try(:classification_label).try(:downcase)
end

#genderized_name(gender = nil) ⇒ `String`^?

Returns:

(String, nil)

# File 'app/models/taxon_name.rb', line 1336

def genderized_name(gender = nil)
  if gender.nil? || is_genus_rank?
    name
  else
    name_in_gender(gender)
  end
end

#get_author ⇒ `Object`

TODO: cleanly isolate getters, setters, and cached builders TODO: remove, this is only used for a strange call in sv_checked cached.

Returns:

String, nil virtual attribute, to ultimately be fixed in db



689
690
691

# File 'app/models/taxon_name.rb', line 689

def get_author
  cached_author_year.to_s.gsub(/,\s\(?\d+\)?\s\[\d+\]|,\s\(?\d+\)?/, '').gsub(') ', ', ').gsub('(', '').gsub(')', '')
end

#get_author_and_year ⇒ `Object`

return [String]

the author and year of the name, adds parenthesis where asserted

# File 'app/models/taxon_name.rb', line 1358

def get_author_and_year
  if self.type == 'Combination'
    c = protonyms_by_rank
    return nil if c.empty?
    taxon = c[c.keys.last]
  else
    taxon = self
  end

  case taxon.rank_class.try(:nomenclatural_code)
  when :iczn
    ay = iczn_author_and_year(taxon)
  when :icvcn
    ay = icn_author_and_year(taxon)
  when :icnp
    ay = icn_author_and_year(taxon)
  when :icn
    ay = icn_author_and_year(taxon)
  else
    ay = ([author_string] + [cached_nomenclature_date&.year]).compact.join(' ')
  end
  (ay.presence)
end

#get_cached_classified_as ⇒ `String`^?

Returns:

(String, nil)

# File 'app/models/taxon_name.rb', line 1476

def get_cached_classified_as
  return nil unless is_protonym? || is_combination?
  # source_classified_as is a method generated through relationships
  r = reload_source_classified_as
  return " (as #{r.name})" if r.present?
  nil
end

#get_cached_misspelling ⇒ `Object`

# File 'app/models/taxon_name.rb', line 1128

def get_cached_misspelling
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_ONLY).first
  unless misspelling.nil?
    n1 = verbatim_name? ? verbatim_name : name
    n2 = misspelling.object_taxon_name.verbatim_name? ? misspelling.object_taxon_name.verbatim_name : misspelling.object_taxon_name.name
    return true if n1 != n2
  end
  nil
end

#get_full_name ⇒ `String`^?

Returns A monominal if names is above genus, or a full epithet if below. Does not include author_year. Does not include HTML.

Returns:

(String, nil) —

A monominal if names is above genus, or a full epithet if below. Does not include author_year. Does not include HTML.

# File 'app/models/taxon_name.rb', line 1275

def get_full_name
  return name_with_misspelling(nil) if type != 'Combination' && !GENUS_AND_SPECIES_RANK_NAMES.include?(rank_string)
  return name if rank_class.to_s =~ /Icvcn/
  return verbatim_name if verbatim_name.present? && is_combination?

  d = full_name_hash

  elements = []

  elements.push(d['genus']) unless (not_binominal? && d['genus'][1] == '[GENUS NOT SPECIFIED]')

  elements.push ['(', d['subgenus'], ')']
  elements.push ['(', d['infragenus'], ')'] if rank_name == 'infragenus'
  elements.push ['(', d['supergenus'], ')'] if rank_name == 'supergenus'
  elements.push ['(', d['supersubgenus'], ')'] if rank_name == 'supersubgenus'
  elements.push ['(', d['supersupersubgenus'], ')'] if rank_name == 'supersupersubgenus'
  elements.push [d['supersuperspecies']] if rank_name == 'supersuperspecies'
  elements.push [d['superspecies']] if rank_name == 'superspecies'
  elements.push [d['subsuperspecies']] if rank_name == 'subsuperspecies'

  elements.push(d['species'], d['subspecies'], d['variety'], d['subvariety'], d['form'], d['subform'])

  elements = elements.flatten.compact.join(' ').gsub(/\(\s*\)/, '').gsub(/\(\s/, '(').gsub(/\s\)/, ')').squish
  elements.presence # nill on empty, false
end

#get_full_name_html(name = nil) ⇒ `Object`

Returns String.

Returns:

String

# File 'app/models/taxon_name.rb', line 1302

def get_full_name_html(name = nil)
  name = get_full_name if name.nil?
  return  "\"<i>Candidatus</i> #{name}\"" if is_candidatus?
  if name.present? && is_hybrid?
    w = name.split(' ')
    w[-1] = ('×' + w[-1]).gsub('×(', '(×')
    name = w.join(' ')
  end

  m = name
  m = Utilities::Italicize.taxon_name(name) if is_italicized?
  m = '† ' + m if is_fossil?
  m
end

#get_genus_species(genus_option, self_option) ⇒ `Object`

return [String, nil, false] # TODO: fix

# File 'app/models/taxon_name.rb', line 1345

def get_genus_species(genus_option, self_option)
  # see Protonym
  true
end

#get_original_combination ⇒ `Object`

Stub, see subclasses TaxonNameRelationships call it for Combinations



1140
1141
1142

# File 'app/models/taxon_name.rb', line 1140

def get_original_combination
  nil
end

#get_original_combination_html ⇒ `Object`

Stub, see subclasses

only Protonym, but TaxonNameRelationships call it for Combinations



1146
1147
1148

# File 'app/models/taxon_name.rb', line 1146

def get_original_combination_html
  nil
end

#get_valid_taxon_name ⇒ `TaxonName`

Returns a valid taxon_name for an invalid name or self for valid name. a stub here - See Protonym and Combination.

Returns:

(TaxonName) —

a valid taxon_name for an invalid name or self for valid name. a stub here - See Protonym and Combination



952
953
954

# File 'app/models/taxon_name.rb', line 952

def get_valid_taxon_name
  nil
end

#icn_author_and_year(taxon) ⇒ `Object`

# File 'app/models/taxon_name.rb', line 1382

def icn_author_and_year(taxon)
  ay = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)
  originally_invalid = TaxonNameRelationship.where_object_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Icn::Unaccepting::OriginallyInvalid').first
  m_obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name
  mobj = misspelling.empty? ? taxon : misspelling.first.object_taxon_name
  ay = mobj.try(:author_string) # author string for basionym
  if self.type == 'Combination'
    cc = self
  else
    current_combination = TaxonNameRelationship.where_object_is_taxon_name(mobj).with_type_string('TaxonNameRelationship::CurrentCombination')
    cc = current_combination.empty? ? self : current_combination.first.subject_taxon_name
  end

  unless originally_invalid.nil?
    ay = originally_invalid.subject_taxon_name.try(:author_string).to_s + ' ex ' + ay.to_s
  end

  if self.author_string.present? && mobj.id != cc.id
    ay = '(' + ay.to_s + ') ' + cc.try(:author_string).to_s
  end

  if !misapplication.empty? && m_obj.author_string.present?
    ay += ' non ' + m_obj.author_string
  end

  (ay.presence)
end

#iczn_author_and_year(taxon) ⇒ `String`^?

Returns the authors, and year, with parentheses as inferred by the data.

Returns:

(String, nil) —

the authors, and year, with parentheses as inferred by the data

# File 'app/models/taxon_name.rb', line 1415

def iczn_author_and_year(taxon)
  ay = nil
  p = nil

  misapplication = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication')
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_STRING)

  mobj = misspelling.empty? ? nil : misspelling.first.object_taxon_name
  if mobj.present?
    a = [mobj.try(:author_string)]
    y = [mobj.try(:year_integer)]
  else
    a = [taxon.try(:author_string)]
    y = [taxon.try(:year_integer)]
  end
  if a[0] =~ /^\(.+\)$/ # (Author)
    a[0] = a[0][1..-2] ## remove parentheses in the author string # TODO: draw from cached_author
    p = true
  else
    p = false
  end

  ay = (a + y).compact.join(', ')

  obj = misapplication.empty? ? nil : misapplication.first.object_taxon_name

  if SPECIES_RANK_NAMES_ICZN.include?(taxon.rank_string)
    if p
      ay = '(' + ay + ')' unless ay.empty?
    else
      og = taxon.original_genus
      if self.type == 'Combination'
        cg = genus
      else
        par = TaxonNameRelationship.where_subject_is_taxon_name(taxon).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING_AUTHOR_PARENTHESES).any?
        cg = (par == false && !misspelling.empty?) ? og : ancestor_at_rank('genus')
      end
      if !og.nil? && !cg.nil?
        ay = '(' + ay + ')' if !ay.empty? && og.normalized_genus.id != cg.normalized_genus.id
      end
    end
  elsif FAMILY_RANK_NAMES_ICZN.include?(taxon.rank_string) && !y.empty? && cached_nomenclature_date&.year != y.first && !mobj.present?
    ay = ay + ' [' + cached_nomenclature_date&.year.to_s + ']'
    ay = ay.gsub(' []', '')
  end

  unless misapplication.empty? || obj.author_string.blank?
    ay += ' non ' + ([obj.author_string] + [obj.year_integer]).compact.join(', ')
  end

  (ay.presence)
end

#is_ambiguously_invalid? ⇒ `Boolean`

Has Classification, but no relationship describing why

Returns:

(Boolean)



900
901
902

# File 'app/models/taxon_name.rb', line 900

def is_ambiguously_invalid?
  !is_valid? && (id == cached_valid_taxon_name_id)
end

#is_candidatus? ⇒ `True|False`

Returns true if this name has a TaxonNameClassification of candidatus.

Returns:

(True|False) —

true if this name has a TaxonNameClassification of candidatus

# File 'app/models/taxon_name.rb', line 932

def is_candidatus?
  return false unless rank_string =~ /Icnp/
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Candidatus').any?
end

#is_combination? ⇒ `Boolean`

Returns:

(Boolean)



914
915
916

# File 'app/models/taxon_name.rb', line 914

def is_combination?
  type == 'Combination'
end

#is_fossil? ⇒ `True|False`

Returns true if this name has a TaxonNameClassification of Fossil.

Returns:

(True|False) —

true if this name has a TaxonNameClassification of Fossil



920
921
922

# File 'app/models/taxon_name.rb', line 920

def is_fossil?
  taxon_name_classifications.with_type_contains('::Fossil').any?
end

#is_genus_or_species_rank? ⇒ `Boolean`

Returns see subclasses.

Returns:

(Boolean) —

see subclasses



945
946
947

# File 'app/models/taxon_name.rb', line 945

def is_genus_or_species_rank?
  false
end

#is_hybrid? ⇒ `Boolean`

Returns true if this name has a TaxonNameClassification of hybrid.

Returns:

(Boolean) —

true if this name has a TaxonNameClassification of hybrid



926
927
928

# File 'app/models/taxon_name.rb', line 926

def is_hybrid?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('Hybrid').any?
end

#is_italicized? ⇒ `Boolean`

Returns whether this name needs italics applied.

Returns:

(Boolean) —

whether this name needs italics applied



906
907
908

# File 'app/models/taxon_name.rb', line 906

def is_italicized?
  is_genus_or_species_rank? || kind_of?(Combination) || kind_of?(Hybrid)
end

#is_protonym? ⇒ `Boolean`

Returns:

(Boolean)



910
911
912

# File 'app/models/taxon_name.rb', line 910

def is_protonym?
  type == 'Protonym'
end

#is_valid? ⇒ `Boolean`

Returns after all inference on the validity of a name, the result is stored in cached_valid_taxon_name_id, #is_valid checks that result.

Returns:

(Boolean) —

after all inference on the validity of a name, the result is stored in cached_valid_taxon_name_id, #is_valid checks that result



895
896
897

# File 'app/models/taxon_name.rb', line 895

def is_valid?
  cached_is_valid
end

#list_of_invalid_taxon_names ⇒ `Array of TaxonName`

Can’t we just use #valid_id now? DD: no this is used for validation of multiple conflicting relationships this list does not return combinations

Returns:

(Array of TaxonName) —

returns list of invalid names for a given taxon.

# File 'app/models/taxon_name.rb', line 979

def list_of_invalid_taxon_names
  first_pass = true
  list = {}
  while first_pass || !list.keys.select{|t| list[t] == false}.empty? do
    first_pass = false
    list_of_taxa_to_check = list.empty? ? [self] : list.keys.select{|t| list[t] == false}
    list_of_taxa_to_check.each do |t|
      potentialy_invalid_relationships = t.related_taxon_name_relationships.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).order_by_oldest_source_first
      potentialy_invalid_relationships.each do |r|
        if !TaxonNameClassification.where_taxon_name(r.subject_taxon_name).with_type_array(TAXON_NAME_CLASS_NAMES_VALID).empty?
          # do nothing, taxon has a status of valid name
        elsif r == r.subject_taxon_name.first_possible_valid_taxon_name_relationship
          list[r.subject_taxon_name] = false if list[r.subject_taxon_name].nil?
        end
      end
      list[t] = true if list[t] == false
    end
  end
  return [] if list.empty?
  list.sort_by{|t, a| (t.cached_nomenclature_date&.to_time || Time.now)}.collect{|t, a| t}
end

#matrix_row_item ⇒ `{"matrix_row_item": matrix_column_item, "object": object}`, `false`

See Shared::MatrixHooks the hash corresponding to the keyword used in this tag if it exists !! Assumes it can only be in one matrix, this is wrong !!

Returns:

({"matrix_row_item": matrix_column_item, "object": object}, false)

# File 'app/models/taxon_name.rb', line 1581

def matrix_row_item
  mri = ObservationMatrixRowItem::TaxonNameRowItem.where(taxon_name_id: id, project_id:).limit(1)

  if mri.any?
    return { matrix_row_item: mri.first, object: taxon_name }
  else
    return false
  end
end

#merge_to(to_taxon_name, kind) ⇒ `Object`

# File 'app/models/taxon_name.rb', line 1604

def merge_to(to_taxon_name, kind)
  @result = {
    failed: 0,
    passed: 0,
    kind:
  }

  case kind
  when :taxon_name_relationships
    all_taxon_name_relationships.each do |r|
      begin
        if r.subject_taxon_name_id == id
          r.update!(subject_taxon_name: to_taxon_name)
        elsif  r.object_taxon_name_id == id
          r.update!(object_taxon_name: to_taxon_name)
        else
          @result[:failed] += 1
        end
        @result[:passed] += 1
      rescue ActiveRecord::RecordInvalid
        @result[:failed] += 1
      end
    end
  else
  end

  @result
end

#minimum_invalidating_year ⇒ `Object`



671
672
673

# File 'app/models/taxon_name.rb', line 671

def minimum_invalidating_year
  [ taxon_name_classification_minimum_invalidating_year, taxon_name_relationship_minimum_invalidating_year ].compact.sort.first
end

#minimum_years_valid ⇒ `Object`

# File 'app/models/taxon_name.rb', line 675

def minimum_years_valid
  a = [year_integer, minimum_invalidating_year].compact
  if a.size == 2
    a.second - a.first
  else
    nil
  end
end

#name_in_gender(gender = nil) ⇒ `Array of Strings`

Returns names of all genera where the species was placed.

Returns:

(Array of Strings) —

names of all genera where the species was placed

# File 'app/models/taxon_name.rb', line 1017

def name_in_gender(gender = nil)
  case gender
  when 'masculine'
    n = masculine_name
  when 'feminine'
    n = feminine_name
  when 'neuter'
    n = neuter_name
  else
    n = nil
  end
  n = (n.presence || name)
  return n
end

#name_is_misapplied? ⇒ `Boolean`

return [Boolean]

whether there is an ICZN missapplication relationship present on this name

Returns:

(Boolean)



1352
1353
1354

# File 'app/models/taxon_name.rb', line 1352

def name_is_misapplied?
  !TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_string('TaxonNameRelationship::Iczn::Invalidating::Misapplication').empty?
end

#name_with_misspelling(gender) ⇒ `String`

Returns TODO: does this form of the name contain parens for subgenus? TODO: provide a default to gender (but do NOT eliminate param) TODO: on third thought- eliminate this mess.

Returns:

(String) —

TODO: does this form of the name contain parens for subgenus? TODO: provide a default to gender (but do NOT eliminate param) TODO: on third thought- eliminate this mess

# File 'app/models/taxon_name.rb', line 1321

def name_with_misspelling(gender)
  if cached_misspelling
    if rank_string =~ /Icnp/
      name.to_s + ' (sic)'
    else
      name.to_s + ' [sic]'
    end
  elsif gender.nil? || rank_string =~ /Genus/
    name.to_s
  else
    name_in_gender(gender).to_s
  end
end

#next_sibling ⇒ `Object`

TODO: this should be paginated, not all IDs!

# File 'app/models/taxon_name.rb', line 1490

def next_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)
    s = sibs.index(id)
    TaxonName.find(sibs[ s + 1] ) if s < sibs.length - 1
  else
    nil
  end
end

#nomeclatural_history ⇒ `array`

returns array of hashes for history of taxon. Could be used for catalogue construction. Probably belongs in catatlog.

Returns:

(array)

# File 'app/models/taxon_name.rb', line 722

def nomeclatural_history
  history = []
  TaxonName.where(cached_valid_taxon_name_id: self.id).order(:cached_nomenclature_date).each do |t|
    item = {}
    source_author_string = t.is_combination? ? [t.origin_citation&.source&.authority_name, t.origin_citation&.source&.year].join(', ') : nil
    source_author_string = ' in ' + source_author_string unless source_author_string.nil?
    item[:name] = t.is_combination? ? t.cached_html : t.cached_original_combination_html
    item[:author_year] = t.is_combination? ? t.cached_author_year + source_author_string : t.original_author_year
    item[:statuses] = t.combined_statuses
    history.append(item)
  end
  return history
end

#nomenclature_date ⇒ `Time`

!! Overrides and references Shared::Citations#nomenclature_date

Returns:

(Time) —

effective date of publication, used to determine nomenclatural priority

# File 'app/models/taxon_name.rb', line 697

def nomenclature_date
  return nil if !persisted?

  if is_protonym?
    if is_family_rank?
      family_before_1961 = TaxonNameRelationship::Iczn::PotentiallyValidating::FamilyBefore1961.where_subject_is_taxon_name(self).first
    end
  end

  if family_before_1961.nil?
    if a = source_nomenclature_date # Alias for nomenclature_date in shared/citations.rb
      a
    else
      year_of_publication ? Time.utc(year_of_publication, 12, 31) : nil
    end
  else
    obj = family_before_1961.object_taxon_name
    year = obj.year_of_publication ? Time.utc(obj.year_of_publication, 12, 31) : nil
    b = obj.source_nomenclature_date
    b ? b : year
  end
end

#normalized_genus ⇒ `Object`

Returns Protonym.

Returns:

Protonym

# File 'app/models/taxon_name.rb', line 1469

def normalized_genus
  misspelling = TaxonNameRelationship.where_subject_is_taxon_name(self).with_type_array(TAXON_NAME_RELATIONSHIP_NAMES_MISSPELLING)
  tn = misspelling.empty? ? self : misspelling.first.object_taxon_name
  return tn.lowest_rank_coordinated_taxon
end

#not_binominal? ⇒ `True|False`

Returns true if this name has a TaxonNameClassification of not_binominal.

Returns:

(True|False) —

true if this name has a TaxonNameClassification of not_binominal



939
940
941

# File 'app/models/taxon_name.rb', line 939

def not_binominal?
  taxon_name_classifications.where_taxon_name(self).with_type_contains('NonBinominal').any?
end

#original_author_year ⇒ `String`^?

Returns derived from cached_author_year !! DO NOT USE IN building cached !! See also app/helpers/taxon_names_helper.

Returns:

(String, nil) —

derived from cached_author_year !! DO NOT USE IN building cached !! See also app/helpers/taxon_names_helper

# File 'app/models/taxon_name.rb', line 836

def original_author_year
  if nomenclatural_code == :iczn && !cached_misspelling && !name_is_misapplied?
    cached_author_year&.gsub(/^\(|\)/, '')
  elsif nomenclatural_code == :icn && cached_author_year
    if matchdata1 = cached_author_year.match(/(\(.*\))/)
      matchdata1[1].gsub(/^\(|\)/, '')
    else
      cached_author_year
    end
  else
    cached_author_year
  end
end

#out_of_scope_combinations ⇒ `Object`

#parent_is_set? ⇒ `Boolean`

Returns:

(Boolean)



1485
1486
1487

# File 'app/models/taxon_name.rb', line 1485

def parent_is_set?
  !parent_id.nil? || (parent&.persisted?)
end

#part_of_speech_class ⇒ `Class`

Returns part of speech of a species as class.

Returns:

(Class) —

part of speech of a species as class.



756
757
758

# File 'app/models/taxon_name.rb', line 756

def part_of_speech_class
  part_of_speech_instance.try(:type_class)
end

#part_of_speech_instance ⇒ `Object`



760
761
762

# File 'app/models/taxon_name.rb', line 760

def part_of_speech_instance
  taxon_name_classifications.with_type_base('TaxonNameClassification::Latinized::PartOfSpeech').first
end

#part_of_speech_name ⇒ `String`

Returns part of speech of a species as string.

Returns:

(String) —

part of speech of a species as string.



766
767
768

# File 'app/models/taxon_name.rb', line 766

def part_of_speech_name
  part_of_speech_instance.try(:classification_label).try(:downcase)
end

#previous_sibling ⇒ `Object`

TODO: this should be paginated, not all IDs!

# File 'app/models/taxon_name.rb', line 1501

def previous_sibling
  if siblings.where(project_id:).any?
    sibs = self_and_siblings.order(:cached).pluck(:id)

    s = sibs.index(id)
    TaxonName.find(sibs[s - 1]) if s != 0
  else
    nil
  end
end

#rank ⇒ `String`

Returns rank as human readable short-form, like ‘genus’ or ‘species’.

Returns:

(String) —

rank as human readable short-form, like ‘genus’ or ‘species’



537
538
539

# File 'app/models/taxon_name.rb', line 537

def rank
  ::RANKS.include?(rank_string) ? rank_name : nil
end

#rank_string ⇒ `String`

Returns rank (Kindom, Phylum…) as a string, like NomenclaturalRank::Iczn::SpeciesGroup::Species.

Returns:

(String) —

rank (Kindom, Phylum…) as a string, like NomenclaturalRank::Iczn::SpeciesGroup::Species



543
544
545

# File 'app/models/taxon_name.rb', line 543

def rank_string
  read_attribute(:rank_class)
end

#reified_id ⇒ `String`

Some observations:

- reified ids are only for original combinations (for which we have no ID)
- reified ids never reference gender changes because they are always in context of original combination, i.e. there is never a gender change

Mental note- consider combination - is_current_placement? (presently excluded in CoL code, which is the correct place to decide that.) Duplicated in COLDP export code

Returns:

(String) —

a reified ID is used when the original combination, which does not yet have it’s own ID, is not the same as the current classification

# File 'app/models/taxon_name.rb', line 1598

def reified_id
  return id.to_s if is_combination?
  return id.to_s unless has_alternate_original?
  id.to_s + '-' + Digest::MD5.hexdigest(cached_original_combination)
end

#related_taxon_names ⇒ `Array of TaxonName`

Returns all taxon_names which have relationships to this taxon as an object or subject.

Returns:

(Array of TaxonName) —

all taxon_names which have relationships to this taxon as an object or subject.

# File 'app/models/taxon_name.rb', line 607

def related_taxon_names
  TaxonName.find_by_sql(
    "SELECT tn.* from taxon_names tn join taxon_name_relationships tnr1 on tn.id = tnr1.subject_taxon_name_id and tnr1.object_taxon_name_id = #{self.id}
    UNION
    SELECT tn.* from taxon_names tn join taxon_name_relationships tnr2 on tn.id = tnr2.object_taxon_name_id and tnr2.subject_taxon_name_id = #{self.id}"
  )
end

#relationship_invalid? ⇒ `Boolean`

Returns true if there is a relationship where then name is asserted to be invalid.

Returns:

(Boolean) —

true if there is a relationship where then name is asserted to be invalid



862
863
864

# File 'app/models/taxon_name.rb', line 862

def relationship_invalid?
  !first_possible_invalid_taxan_name_relationship.nil?
end

#safe_self_and_ancestors ⇒ `Array of TaxonName`

Uses parent recursion when record is new and awesome_nested_set_is_not_usable

Returns:

(Array of TaxonName) —

an list of ancestors, Root first

# File 'app/models/taxon_name.rb', line 1168

def safe_self_and_ancestors
  if new_record?
    ancestors_through_parents
  else
    # self_and_ancestors.reload.to_a.reverse ## .self_and_ancestors returns empty array!!!!!!!

    self_and_ancestors
      .unscope(:order)
      .order(generations: :DESC)
      .reload # TODO Why needed? Should not be
      .to_a
  end
end

#set_cached ⇒ `Object`

TODO: We need to isolate this into 2 subclasses, 1 - cached methods that touch author/year 2 - cached methods that do not

# File 'app/models/taxon_name.rb', line 1056

def set_cached
  n = get_full_name # memoize/var into taxonomy?
  update_column(:cached, n)

  # Combination should have it's own cached setting methods
  # We can't use the in-memory cache approach for combination names, force reload each time
  n = nil if is_combination?

  update_columns(
    cached_html: get_full_name_html(n)
  )

  # one more query, but can be isolated now
  set_cached_nomenclature_date

  # Dependent on TaxonNameClassification and TaxonNameRelationship
  # !! Technically these should not be here.

  # TODO: Isolate and optimize. These an be isolated as they are not always pertinent to a generalized cascading cache setting
  # For example, when a TaxonName relationship forces a cached reload it may/not need to call these two things

  set_cached_valid_taxon_name_id
  set_cached_is_valid
  set_cached_classified_as

  set_cached_author_columns
end

#set_cached_author ⇒ `Object`



1120
1121
1122

# File 'app/models/taxon_name.rb', line 1120

def set_cached_author
  update_column(:cached_author, get_author)
end

#set_cached_author_columns ⇒ `Object`

See TaxonNameAuthor

# File 'app/models/taxon_name.rb', line 1089

def set_cached_author_columns
  # TODO: build author year from cached author and year, not the other way around
  #  * at this point we have already updated date
  set_cached_author_year
  set_cached_author # should be after the 'set_cached_author_year
end

#set_cached_author_year ⇒ `Object`



1116
1117
1118

# File 'app/models/taxon_name.rb', line 1116

def set_cached_author_year
  update_column(:cached_author_year, get_author_and_year)
end

#set_cached_classified_as ⇒ `Object`



1124
1125
1126

# File 'app/models/taxon_name.rb', line 1124

def set_cached_classified_as
  update_column(:cached_classified_as, get_cached_classified_as)
end

#set_cached_is_valid ⇒ `Object`

# File 'app/models/taxon_name.rb', line 1100

def set_cached_is_valid
  v = is_combination? ? false : !unavailable_or_invalid?
  update_column(:cached_is_valid, v)
end

#set_cached_nomenclature_date ⇒ `Object`



1084
1085
1086

# File 'app/models/taxon_name.rb', line 1084

def set_cached_nomenclature_date
  update_columns(cached_nomenclature_date: nomenclature_date)
end

#set_cached_valid_taxon_name_id ⇒ `Object`



1096
1097
1098

# File 'app/models/taxon_name.rb', line 1096

def set_cached_valid_taxon_name_id
  update_column(:cached_valid_taxon_name_id, get_valid_taxon_name.id)
end

#set_cached_warnings ⇒ `Object`

# File 'app/models/taxon_name.rb', line 1105

def set_cached_warnings
  update_columns(
    cached:  NO_CACHED_MESSAGE,
    cached_author_year:  NO_CACHED_MESSAGE,
    cached_author: NO_CACHED_MESSAGE,
    cached_nomenclature_date: NO_CACHED_MESSAGE,
    cached_classified_as: NO_CACHED_MESSAGE,
    cached_html:  NO_CACHED_MESSAGE
  )
end

#statuses_from_classifications ⇒ `Array of String`

Returns the unique string labels (human readable) derived from TaxonNameClassifications.

Returns:

(Array of String) —

the unique string labels (human readable) derived from TaxonNameClassifications

# File 'app/models/taxon_name.rb', line 772

def statuses_from_classifications
  list = taxon_name_classifications_for_statuses
  list.empty? ? [] : list.collect{|c| c.classification_label }.sort
end

#statuses_from_relationships ⇒ `Array of String`

Returns the unique string labels derived from and TaxonNameRelationships.

Returns:

(Array of String) —

the unique string labels derived from and TaxonNameRelationships

# File 'app/models/taxon_name.rb', line 784

def statuses_from_relationships
  list = taxon_name_relationships.with_type_array(STATUS_TAXON_NAME_RELATIONSHIP_NAMES)
  list.empty? ? [] : list.collect{|c| c.subject_status}.sort
end

#sv_cached_names ⇒ `Object` (protected)



1824
1825
1826

# File 'app/models/taxon_name.rb', line 1824

def sv_cached_names
  true # see validation in subclasses
end

#sv_combination_duplicates ⇒ `Object` (protected)



1876
1877
1878

# File 'app/models/taxon_name.rb', line 1876

def sv_combination_duplicates
  true # see validation in Combination.rb
end

#sv_conflicting_subordinate_taxa ⇒ `Object` (protected)

# File 'app/models/taxon_name.rb', line 1772

def sv_conflicting_subordinate_taxa
  classifications = self.taxon_name_classifications.reload
  classification_names = classifications.map { |i| i.type_name }
  compare = TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID & classification_names
  unless compare.empty?
    unless Protonym.with_parent_taxon_name(self).without_taxon_name_classification_array(TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).empty?
      compare.each do |i|
        # taxon is unavailable or invalid, but has valid children
        soft_validations.add(:base, "Taxon has a status ('#{i.safe_constantize.label}') conflicting with presence of subordinate taxa")
      end
    end
  end
end

#sv_fix_cached_names ⇒ `Object` (protected)

TODO: This can be made more specific, we don’t need to call some of the methods in set_cached It also should never be required.

# File 'app/models/taxon_name.rb', line 1788

def sv_fix_cached_names
  begin
    TaxonName.transaction do
      self.set_cached
    end
    true
  rescue
    false
  end
end

#sv_fix_parent_is_valid_name ⇒ `Object` (protected)

# File 'app/models/taxon_name.rb', line 1749

def sv_fix_parent_is_valid_name
  res = false
  if self.parent.unavailable_or_invalid?
    new_parent = self.parent.get_valid_taxon_name
    if self.parent != new_parent
      self.parent = new_parent
      if self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::GenusGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::SpeciesGroup::Subspecies'
        self.rank_class = 'NomenclaturalRank::Iczn::SpeciesGroup::Species'
      elsif self.parent.rank_class.parent.to_s == 'NomenclaturalRank::Iczn::FamilyGroup' && self.rank_class.to_s == 'NomenclaturalRank::Iczn::GenusGroup::Subgenus'
        self.rank_class = 'NomenclaturalRank::Iczn::GenusGroup::Genus'
      end
      begin
        TaxonName.transaction do
          self.save
          res = true
        end
      rescue # TODO: Qualify this!!
      end
    end
  end
  res
end

#sv_homotypic_synonyms ⇒ `Object` (protected)



1868
1869
1870

# File 'app/models/taxon_name.rb', line 1868

def sv_homotypic_synonyms
  true # see validation in Protonym.rb
end

#sv_hybrid_name_relationships ⇒ `Object` (protected)



1880
1881
1882

# File 'app/models/taxon_name.rb', line 1880

def sv_hybrid_name_relationships
  true # see validation in Hybrid.rb
end

#sv_incomplete_combination ⇒ `Object` (protected)

# File 'app/models/taxon_name.rb', line 1815

def sv_incomplete_combination
  soft_validations.add(:base, 'The genus in the combination is not specified') if !cached.nil? && cached.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the combination is not specified') if !cached.nil? && cached.include?('SPECIES NOT SPECIFIED')
  soft_validations.add(:base, 'The variety in the combination is not specified') if !cached.nil? && cached.include?('VARIETY NOT SPECIFIED')
  soft_validations.add(:base, 'The form in the combination is not specified') if !cached.nil? && cached.include?('FORM NOT SPECIFIED')
  soft_validations.add(:base, 'The genus in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('GENUS NOT SPECIFIED')
  soft_validations.add(:base, 'The species in the original combination is not specified') if !cached_original_combination.nil? && cached_original_combination.include?('SPECIES NOT SPECIFIED')
end

#sv_missing_classifications ⇒ `Object` (protected)



1840
1841
1842

# File 'app/models/taxon_name.rb', line 1840

def sv_missing_classifications
  true # see validation in Protonym.rb
end

#sv_missing_confidence_level ⇒ `Object` (protected)

TODO: this needs to go.

# File 'app/models/taxon_name.rb', line 1700

def sv_missing_confidence_level # should be removed once the alternative solution is implemented. It is heavily used now.
  confidence_level_array = [93]
confidence_level_array = confidence_level_array & ConfidenceLevel.where(project_id: self.project_id).pluck(:id)
soft_validations.add(:base, 'Confidence level is missing') if !confidence_level_array.empty? && (self.confidences.pluck(:confidence_level_id) & confidence_level_array).empty?
end

#sv_missing_etymology ⇒ `Object` (protected)

def sv_missing_author

true # see Protonym

end

def sv_missing_year

true # see Protonym

end



1739
1740
1741

# File 'app/models/taxon_name.rb', line 1739

def sv_missing_etymology
  true # see Protonym
end

#sv_missing_original_publication ⇒ `Object` (protected)

# File 'app/models/taxon_name.rb', line 1706

def sv_missing_original_publication
  if rank_class.nil? || is_family_or_genus_or_species_rank?
    if self.source.nil?
      soft_validations.add(:base, 'Original publication is not selected')
    elsif self.origin_citation.try(:pages).blank?
      soft_validations.add(:base, 'Original citation pages are not recorded')
    elsif self.source.pages.present?
      matchdata1 = self.origin_citation.pages.match(/^(\d+) ?[-–] ?(\d+)$|^(\d+)$/)
      if matchdata1
        citMinP = matchdata1[1] ? matchdata1[1].to_i : matchdata1[3].to_i
        citMaxP = matchdata1[2] ? matchdata1[2].to_i : matchdata1[3].to_i
        matchdata = self.source.pages.match(/(\d+) ?[-–] ?(\d+)|(\d+)/)
        if citMinP && citMaxP && matchdata
          minP = matchdata[1] ? matchdata[1].to_i : matchdata[3].to_i
          maxP = matchdata[2] ? matchdata[2].to_i : matchdata[3].to_i
          minP = 1 if minP == maxP && %w{book booklet manual mastersthesis phdthesis techreport}.include?(self.source.bibtex_type)
          unless (maxP && minP && minP <= citMinP && maxP >= citMaxP)
            soft_validations.add(:base, 'Original citation could be out of the source page range')
          end
        end
      end
    end
  end
end

#sv_missing_relationships ⇒ `Object` (protected)



1832
1833
1834

# File 'app/models/taxon_name.rb', line 1832

def sv_missing_relationships
  true # see validation in Protonym.rb
end

#sv_not_synonym_of_self ⇒ `Object` (protected)

Required for synonyms of synomyms

# File 'app/models/taxon_name.rb', line 1800

def sv_not_synonym_of_self
  if list_of_invalid_taxon_names.include?(self)
    soft_validations.add(:base, "Taxon has two conflicting relationships (invalidating and validating). To resolve a conflict, add a status 'Valid' to a valid taxon.")
  end
end

#sv_parent_is_valid_name ⇒ `Object` (protected)

# File 'app/models/taxon_name.rb', line 1743

def sv_parent_is_valid_name
  if !parent.nil? && parent.unavailable_or_invalid?
    soft_validations.add(:parent_id, 'Parent should be a valid taxon', success_message: 'Parent was updated', failure_message:  'Failed to update parent')
  end
end

#sv_parent_priority ⇒ `Object` (protected)



1864
1865
1866

# File 'app/models/taxon_name.rb', line 1864

def sv_parent_priority
  true # see validation in Protonym.rb
end

#sv_potential_homonyms ⇒ `Object` (protected)



1872
1873
1874

# File 'app/models/taxon_name.rb', line 1872

def sv_potential_homonyms
  true # see validation in Protonym.rb
end

#sv_primary_types ⇒ `Object` (protected)



1848
1849
1850

# File 'app/models/taxon_name.rb', line 1848

def sv_primary_types
  true # see validation in Protonym.rb
end

#sv_single_sub_taxon ⇒ `Object` (protected)



1860
1861
1862

# File 'app/models/taxon_name.rb', line 1860

def sv_single_sub_taxon
  true # see validation in Protonym.rb
end

#sv_species_gender_agreement ⇒ `Object` (protected)



1844
1845
1846

# File 'app/models/taxon_name.rb', line 1844

def sv_species_gender_agreement
  true # see validation in Protonym.rb
end

#sv_two_unresolved_alternative_synonyms ⇒ `Object` (protected)

# File 'app/models/taxon_name.rb', line 1806

def sv_two_unresolved_alternative_synonyms
  r = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM)
  if r.to_a.size > 1
    if r.first.nomenclature_date.to_date == r.second.nomenclature_date.to_date
      soft_validations.add(:base, 'Taxon has two alternative invalidating relationships with identical dates. To resolve ambiguity, add original sources to the relationships with different priority dates.')
    end
  end
end

#sv_type_placement ⇒ `Object` (protected)



1856
1857
1858

# File 'app/models/taxon_name.rb', line 1856

def sv_type_placement
  true # see validation in Protonym.rb
end

#sv_validate_coordinated_names ⇒ `Object` (protected)



1852
1853
1854

# File 'app/models/taxon_name.rb', line 1852

def sv_validate_coordinated_names
  true # see validation in Protonym.rb
end

#sv_validate_name ⇒ `Object` (protected)



1836
1837
1838

# File 'app/models/taxon_name.rb', line 1836

def sv_validate_name
  true # see validation in Protonym.rb
end

#sv_validate_parent_rank ⇒ `Object` (protected)



1828
1829
1830

# File 'app/models/taxon_name.rb', line 1828

def sv_validate_parent_rank
  true # see validation in Protonym.rb
end

#synonyms ⇒ `Scope`

Returns Protonym(s) the **broad sense** synonyms of this name.

Returns:

(Scope) —

Protonym(s) the **broad sense** synonyms of this name



531
532
533

# File 'app/models/taxon_name.rb', line 531

def synonyms
  TaxonName.with_cached_valid_taxon_name_id(self.id)
end

#taxon_name_classification_minimum_invalidating_year ⇒ `Object`

# File 'app/models/taxon_name.rb', line 657

def taxon_name_classification_minimum_invalidating_year
  a = taxon_name_classifications.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_CLASS_NAMES_UNAVAILABLE_AND_INVALID).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

#taxon_name_classifications_for_statuses ⇒ `Scope`

Returns:

(Scope)



778
779
780

# File 'app/models/taxon_name.rb', line 778

def taxon_name_classifications_for_statuses
  taxon_name_classifications.with_type_array(ICZN_TAXON_NAME_CLASSIFICATION_NAMES + ICN_TAXON_NAME_CLASSIFICATION_NAMES + ICNP_TAXON_NAME_CLASSIFICATION_NAMES + ICVCN_TAXON_NAME_CLASSIFICATION_NAMES)
end

#taxon_name_relationship_minimum_invalidating_year ⇒ `Object`

Returns Year,nil based on TaxonNameRelationships only at present.

Returns:

Year,nil based on TaxonNameRelationships only at present

# File 'app/models/taxon_name.rb', line 643

def taxon_name_relationship_minimum_invalidating_year
  a = taxon_name_relationships.includes(:source).order_by_oldest_source_first.with_type_array(::TAXON_NAME_RELATIONSHIP_NAMES_SYNONYM).first
  if a
    b = a.nomenclature_date&.year
    if b == Date.current.year
      return nil
    else
      b
    end
  else
    nil
  end
end

#unavailable_or_invalid? ⇒ `Boolean`

@return [Boolean]

return true if name is unavailable OR invalid, else false, checks both classifications and relationships

!! Should only be referenced when building cached values, all other uses should rather be ‘!is_valid?`

Returns:

(Boolean)

# File 'app/models/taxon_name.rb', line 887

def unavailable_or_invalid?
  return false if classification_valid?
  classification_invalid_or_unavailable? || relationship_invalid?
end

#validate_one_root_per_project ⇒ `Object` (protected)

# File 'app/models/taxon_name.rb', line 1656

def validate_one_root_per_project
  if new_record? || parent_id_changed? # project_id !?@
    if !parent_is_set? && TaxonName.where(parent_id: nil, project_id:).count > 0
      errors.add(:parent_id, 'should not be empty/only one root is allowed per project')
    end
  end
end

#validate_parent_from_the_same_project ⇒ `Object` (protected)

# File 'app/models/taxon_name.rb', line 1650

def validate_parent_from_the_same_project
  if parent && project_id.present?
    errors.add(:project_id, 'The parent taxon is not from the same project') if project_id != parent.project_id
  end
end

#validate_parent_is_set ⇒ `Object` (protected)

# File 'app/models/taxon_name.rb', line 1644

def validate_parent_is_set
  if !(rank_class == NomenclaturalRank) && !(type == 'Combination')
    errors.add(:parent_id, 'is not selected') if !parent_is_set?
  end
end

#validate_rank_class_class ⇒ `Object` (protected)

See subclasses



1676
1677
1678

# File 'app/models/taxon_name.rb', line 1676

def validate_rank_class_class
  true
end

#validate_source_type ⇒ `Object` (protected)

# File 'app/models/taxon_name.rb', line 1691

def validate_source_type
  a = source && source.type != 'Source::Bibtex'
  b = origin_citation && origin_citation.try(:source).try(:type) != 'Source::Bibtex'
  if a || b
    errors.add(:base, 'Source must be a Bibtex')
  end
end

#year_integer ⇒ `Integer`

Returns a 4 digit integer representing year of publication, like 1974.

Returns:

(Integer) —

a 4 digit integer representing year of publication, like 1974

# File 'app/models/taxon_name.rb', line 636

def year_integer
  return year_of_publication if !year_of_publication.nil?
  try(:source).try(:year)
end

Class: TaxonName

Overview

Direct Known Subclasses

Defined Under Namespace

Constant Summary collapse

Constants included from SoftValidation

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from MatrixHooks

Methods included from Shared::MatrixHooks::Dynamic

Methods included from Shared::MatrixHooks::Member

Methods included from Shared::IsData

Methods included from SoftValidation

Methods included from Shared::Labels

Methods included from Shared::HasPapertrail

Methods included from Shared::AlternateValues

Methods included from Shared::Confidences

Methods included from Shared::Citations

Methods included from Shared::Depictions

Methods included from Shared::Notes

Methods included from Shared::Identifiers

Methods included from Shared::Tags

Methods included from Shared::DataAttributes

Methods included from Housekeeping

Methods inherited from ApplicationRecord

Instance Attribute Details

#also_create_otu ⇒ Boolean

#cached ⇒ String

#cached_author ⇒ String?

#cached_author_year ⇒ String?

#cached_classified_as ⇒ String

#cached_html ⇒ String

#cached_misspelling ⇒ Boolean

#cached_original_combination ⇒ String

#cached_original_combination_html ⇒ String

#cached_primary_homonym ⇒ String

#cached_primary_homonym_alternative_spelling ⇒ String

#cached_secondary_homonym ⇒ String

#cached_secondary_homonym_alternative_spelling ⇒ String

#etymology ⇒ String

#feminine_name ⇒ String

#masculine_name ⇒ String

#name ⇒ String?

#neuter_name ⇒ String

#no_cached ⇒ Boolean

#parent_id ⇒ Integer

#project_id ⇒ Integer

#rank_class ⇒ NomenclaturalRank class

#taxonomy(rebuild = false) ⇒ Object (readonly)

#type ⇒ String

#verbatim_author ⇒ String

#verbatim_name ⇒ String

#year_of_publication ⇒ Integer

Class Method Details

.calculated_invalid ⇒ Object

.calculated_valid ⇒ Object

.foo(rank_classes) ⇒ Object

.not_leaves ⇒ Object

.out_of_scope_combinations(taxon_name_id) ⇒ Scope

.parent ⇒ Object

.select_optimized(user_id, project_id, target: nil) ⇒ Hash

.sort_by_rank(taxon_names) ⇒ Array of TaxonName

.used_recently(user_id, project_id, target: nil) ⇒ Array

.used_recently_in_classifications(user_id, project_id) ⇒ Scope

.used_recently_in_relationships(user_id, project_id) ⇒ Scope

.with_taxon_name_relationship(relationship) ⇒ Object

Instance Method Details

#all_taxon_name_relationships ⇒ Array

#ancestor_at_rank(rank, include_self = false) ⇒ TaxonName?

#ancestor_hash ⇒ Object

#ancestor_protonyms ⇒ Array of TaxonName

#ancestors_through_parents(result = [self], start = self) ⇒ Array

#author_string ⇒ String?

#cached_html_name_and_author_year ⇒ String

#cached_html_original_name_and_author_year ⇒ String

#cached_name_and_author_year ⇒ String

#check_for_children ⇒ Object (protected)

#check_new_parent_class ⇒ Object (protected)

#check_new_rank_class ⇒ Object (protected)

#also_create_otu ⇒ `Boolean`

#cached ⇒ `String`

#cached_author ⇒ `String`^?

#cached_author_year ⇒ `String`^?

#cached_classified_as ⇒ `String`

#cached_html ⇒ `String`

#cached_misspelling ⇒ `Boolean`

#cached_original_combination ⇒ `String`

#cached_original_combination_html ⇒ `String`

#cached_primary_homonym ⇒ `String`

#cached_primary_homonym_alternative_spelling ⇒ `String`

#cached_secondary_homonym ⇒ `String`

#cached_secondary_homonym_alternative_spelling ⇒ `String`

#etymology ⇒ `String`

#feminine_name ⇒ `String`

#masculine_name ⇒ `String`

#name ⇒ `String`^?

#neuter_name ⇒ `String`

#no_cached ⇒ `Boolean`

#parent_id ⇒ `Integer`

#project_id ⇒ `Integer`

#rank_class ⇒ `NomenclaturalRank class`

#taxonomy(rebuild = false) ⇒ `Object` (readonly)

#type ⇒ `String`

#verbatim_author ⇒ `String`

#verbatim_name ⇒ `String`

#year_of_publication ⇒ `Integer`

.calculated_invalid ⇒ `Object`

.calculated_valid ⇒ `Object`

.foo(rank_classes) ⇒ `Object`

.not_leaves ⇒ `Object`

.out_of_scope_combinations(taxon_name_id) ⇒ `Scope`

.parent ⇒ `Object`

.select_optimized(user_id, project_id, target: nil) ⇒ `Hash`

.sort_by_rank(taxon_names) ⇒ `Array of TaxonName`

.used_recently(user_id, project_id, target: nil) ⇒ `Array`

.used_recently_in_classifications(user_id, project_id) ⇒ `Scope`

.used_recently_in_relationships(user_id, project_id) ⇒ `Scope`

.with_taxon_name_relationship(relationship) ⇒ `Object`

#all_taxon_name_relationships ⇒ `Array`

#ancestor_at_rank(rank, include_self = false) ⇒ `TaxonName`^?

#ancestor_hash ⇒ `Object`

#ancestor_protonyms ⇒ `Array of TaxonName`

#ancestors_through_parents(result = [self], start = self) ⇒ `Array`

#author_string ⇒ `String`^?

#cached_html_name_and_author_year ⇒ `String`

#cached_html_original_name_and_author_year ⇒ `String`

#cached_name_and_author_year ⇒ `String`

#check_for_children ⇒ `Object` (protected)

#check_new_parent_class ⇒ `Object` (protected)

#check_new_rank_class ⇒ `Object` (protected)

#classification_invalid_or_unavailable? ⇒ `Boolean`

#classification_unavailable? ⇒ `Boolean`

#classification_valid? ⇒ `Boolean`

#clear_cached(update: false) ⇒ `Object`

#combination_list_all ⇒ `Array of Protonym`

#combination_list_self ⇒ `Array of Protonym`

#combined_statuses ⇒ `Array of String`

#create_otu ⇒ `Object`

#descendant_protonyms ⇒ `Array of TaxonName`

#descendants_at_rank(rank) ⇒ `Object`

#first_possible_invalid_taxan_name_relationship ⇒ `Object`

#first_possible_valid_taxon_name ⇒ `TaxonName`

#first_possible_valid_taxon_name_relationship ⇒ `TaxonNameRelationship`

#full_name_array ⇒ `rank`, ...

#full_name_hash ⇒ `Object`

#gbif_status_array ⇒ `Object`

#gender_class ⇒ `Class`^?

#gender_instance ⇒ `TaxonNameClassification instance`^?

#gender_name ⇒ `String`^?

#genderized_name(gender = nil) ⇒ `String`^?

#get_author ⇒ `Object`

#get_author_and_year ⇒ `Object`

#get_cached_classified_as ⇒ `String`^?

#get_cached_misspelling ⇒ `Object`

#get_full_name ⇒ `String`^?

#get_full_name_html(name = nil) ⇒ `Object`

#get_genus_species(genus_option, self_option) ⇒ `Object`

#get_original_combination ⇒ `Object`

#get_original_combination_html ⇒ `Object`