github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/core/datamodel/acces.go

// Ce package ajoute de l'intelligence aux données:
//	- résolutions des liens entre tables
//	- fonctions de recherches
//	- implémentation des interfaces
package datamodel

import (
	"bytes"
	"fmt"
	"html/template"
	"sort"
	"strings"

	"github.com/benoitkugler/goACVE/logs"

	"github.com/benoitkugler/goACVE/server/core/rawdata/composites"

	rd "github.com/benoitkugler/goACVE/server/core/rawdata"
)

const (
	CouleurAgeInvalide       = rd.HexColor("#80ea0000")
	CouleurAttenteReponse    = rd.HexColor("#90e0d616")
	CouleurListeAttente      = rd.HexColor("#90FF610F")
	CouleurAnniversaire      = rd.HexColor("#826a1b")
	CouleurPaiementInvalide  = rd.HexColor("#90e0552a")
	CouleurPaiementBordereau = rd.HexColor("#9062872b")
	CouleurResponsable       = rd.HexColor("#4a086d11")
)

const (
	PubEte OptionExport = iota
	PubHiver
	EchoRocher
)

const (
	MembresTriAlphabetique OptionExport = iota
	MembresTriCotisation
)

var (
	CouleurGarcon         = rd.RGBA{R: 19, G: 139, B: 215, A: 50}
	CouleurFille          = rd.RGBA{R: 199, G: 10, B: 126, A: 50}
	CouleurParticipantTmp = rd.RGBA{R: 230, G: 157, B: 51, A: 130}

	headerFacture = []string{
		"Participant",
		"Camp",
		"Dates",
		"Prix du camp",
		"Aides extérieures",
		"Sous-total",
	}

	templateRowFacture = template.Must(template.New("rowFacture").Parse(`<tr>
		<td>
			{{ .Personne.NomPrenom }} <br/>
			(né{{ .Personne.Sexe.Accord }} le {{ .Personne.DateNaissance }}
		</td>
		<td>
			{{ .Camp.Label }} <br/>
			N° JS : {{ .Camp.NumeroJS }}
		</td>
		<td>
			du {{ .Camp.DateDebut }} <br />
			au {{ .Camp.DateFin }}
		</td>
		<td>
			{{ .BilanPrix.PrixBase }} {{ .BilanPrix.DescriptionPrix }}
		</td>
		<td>
			{{ range .BilanPrix.Aides }} 
				{{- if .Valide -}}	
					{{ .Description }} <br/>
				{{- else -}}
					(<i>{{ .Description }}</i>) <br/>
				{{- end }}
			{{ end }}
		</td>
		<td>
			{{ .BilanPrix.PrixSansRemises }}
		</td>
	</tr>`))
)

type dataTemplateFacture struct {
	Personne  rd.Personne
	Camp      rd.Camp
	BilanPrix BilanPrixCamp
}

// --------------------------------------------------------------------------
// -------------------------------Personne ----------------------------------
// --------------------------------------------------------------------------

type OptionExport int

type CacheContacts map[int64][]rd.Organisme // id personnes -> structures contacts

func (b *BaseLocale) ResoudOrganismes() CacheContacts {
	out := CacheContacts{}
	for _, orga := range b.Organismes {
		if contact := orga.IdContact; contact.IsNotNil() {
			out[contact.Int64] = append(out[contact.Int64], orga)
		}
	}
	return out
}

func (ac AccesPersonne) GetDocuments(cache LiensPersonneDocuments) []AccesDocumentPersonne {
	if cache == nil {
		cache = ac.Base.ResoudDocumentsPersonnes()
	}
	ids := cache[ac.Id]
	out := make([]AccesDocumentPersonne, len(ids))
	for i, id := range ids {
		out[i] = AccesDocumentPersonne{ac.Base.NewDocument(id)}
	}
	return out
}

// HasDocument renvoie `true` si la personne possède un document
// dans la catégorie donnée.
func (ac AccesPersonne) HasDocument(cache LiensPersonneDocuments, categorie rd.BuiltinContrainte) bool {
	for _, doc := range ac.GetDocuments(cache) {
		if doc.GetContrainte().Builtin == categorie {
			return true
		}
	}
	return false
}

// IsSB renvoie `true` si la personne a un document dans la catégorie SB.
func (ac AccesPersonne) IsSB(cache LiensPersonneDocuments) rd.Bool {
	return rd.Bool(ac.HasDocument(cache, rd.CSb))
}

// --------------------------------------------------------------------------
// ------------------------------- Camp -------------------------------------
// --------------------------------------------------------------------------

// StatsCamp décrit le nombre de personnes dans différentes catégories.
type StatsCamp struct {
	Inscrits, Attente, Equipe, PlacesRestantes, PlacesReservees, Garcons, Filles int
}

func (ac AccesCamp) GetGroupes() []rd.Groupe {
	var out []rd.Groupe
	for _, groupe := range ac.Base.Groupes {
		if groupe.IdCamp == ac.Id {
			out = append(out, groupe)
		}
	}
	return out
}

func (ac AccesCamp) GetDirecteurEquipier() (AccesEquipier, bool) {
	dir, has := ac.getEquipeMap(nil).FindDirecteur()
	return ac.Base.NewEquipier(dir.Id), has
}

func (ac AccesCamp) GetDirecteur() (AccesPersonne, bool) {
	dir, ok := ac.GetDirecteurEquipier()
	if ok {
		return dir.GetPersonne(), true
	}
	return AccesPersonne{}, false
}

func (ac AccesCamp) hintsAttente(cache LiensCampParticipants, personne rd.Personne, isCurrentInscrit bool) rd.HintsAttente {
	parts := ac.getParticipants(cache)
	cp := composites.CampParticipants{Camp: ac.RawData(), Participants: parts}
	return cp.HintsAttente(personne.BasePersonne, isCurrentInscrit, ac.Base.Personnes)
}

// HintsAttente renvoie le statut conseillé pour le "participant" donné par
// `idPersonne`. Pour un participant déjà créé, voir `AccesParticipant.HintsAttente`
func (ac AccesCamp) HintsAttente(idPersonne int64, isCurrrentInscrit bool) rd.HintsAttente {
	personne := ac.Base.Personnes[idPersonne]
	return ac.hintsAttente(nil, personne, isCurrrentInscrit)
}

// Remplissage renvoi le ratio en % de remplissage du camp
// Si `cache` est nil, parcourt la table des participants.
func (ac AccesCamp) Remplissage(cache1 LiensCampParticipants, cache2 LiensCampParticipantsimples) rd.Pourcent {
	nbInscrits := ac.GetNbInscrits(cache1, cache2)
	nbPlaces := ac.RawData().NbPlaces
	var remp rd.Pourcent
	if nbPlaces > 0 {
		remp = rd.Pourcent(nbInscrits * 100 / int(nbPlaces))
	}
	return remp
}

// GetNbInscrits renvoie le nombre de participant effectif (sans liste d'attente)
func (ac AccesCamp) GetNbInscrits(cache1 LiensCampParticipants, cache2 LiensCampParticipantsimples) int {
	if ac.RawData().InscriptionSimple {
		return len(ac.GetParticipantsimples(cache2))
	}
	return len(ac.GetInscrits(cache1))
}

func (ac AccesCamp) getParticipants(cache LiensCampParticipants) (parts []rd.Participant) {
	if cache == nil {
		_, cache = ac.Base.ResoudParticipants()
	}
	ids := cache[ac.Id]
	parts = make([]rd.Participant, len(ids))
	for index, id := range ids {
		parts[index] = ac.Base.Participants[id]
	}
	return parts
}

// Si `cache` est nil, parcourt la table des participants.
func (ac AccesCamp) GetInscrits(cache LiensCampParticipants) []AccesParticipant {
	var liste []AccesParticipant
	for _, part := range ac.getParticipants(cache) {
		if part.ListeAttente.IsInscrit() {
			liste = append(liste, ac.Base.NewParticipant(part.Id))
		}
	}
	return liste
}

// Si `cache` est nil, parcourt la table des participants.
func (ac AccesCamp) GetAttente(cache LiensCampParticipants) []AccesParticipant {
	var liste []AccesParticipant
	for _, part := range ac.getParticipants(cache) {
		if !part.ListeAttente.IsInscrit() {
			liste = append(liste, ac.Base.NewParticipant(part.Id))
		}
	}
	return liste
}

func (ac AccesCamp) GetParticipantsimples(cache LiensCampParticipantsimples) []AccesParticipantsimple {
	if cache == nil {
		cache = ac.Base.ResoudParticipantsimples()
	}
	ids := cache[ac.Id]
	parts := make([]AccesParticipantsimple, len(ids))
	for index, id := range ids {
		parts[index] = ac.Base.NewParticipantsimple(id)
	}
	return parts
}

func (ac AccesCamp) getEquipeMap(cache LiensCampEquipiers) rd.Equipiers {
	if cache == nil {
		cache = ac.Base.ResoudEquipiers()
	}
	ids := cache[ac.Id]
	out := make(rd.Equipiers, len(ids))
	for _, id := range ids {
		out[id] = ac.Base.Equipiers[id]
	}
	return out
}

// Si `cache` est nil, parcourt la table des equipier.
func (ac AccesCamp) GetEquipe(cache LiensCampEquipiers) []AccesEquipier {
	var liste []AccesEquipier
	for id := range ac.getEquipeMap(cache) {
		liste = append(liste, ac.Base.NewEquipier(id))
	}

	sort.Slice(liste, func(i, j int) bool {
		return liste[i].Id < liste[j].Id
	})
	sort.SliceStable(liste, func(i, j int) bool {
		return liste[i].RawData().Roles.Sortable() < liste[j].RawData().Roles.Sortable()
	})
	return liste
}

// TriParticipants trie `l` sur place par ordre alphabétique, et
// par groupe si demandé.
func TriParticipants(l []AccesParticipant, triGroupe bool) {
	sort.Slice(l, func(i, j int) bool {
		return l[i].GetPersonne().RawData().Prenom.Sortable() < l[j].GetPersonne().RawData().Prenom.Sortable()
	})
	sort.SliceStable(l, func(i, j int) bool {
		return l[i].GetPersonne().RawData().Nom.Sortable() < l[j].GetPersonne().RawData().Nom.Sortable()
	})
	if triGroupe {
		sort.SliceStable(l, func(i, j int) bool {
			gi, _ := l[i].GetGroupe()
			gj, _ := l[j].GetGroupe()
			return gi.Id < gj.Id
		})
	}
}

// TriParticipantsItems trie `l` sur place par ordre alphabétique, et
// par groupe si demandé.
func TriParticipantsItems(parts rd.Table, triGroupe bool) {
	SortBy(parts, PersonnePrenom, false)
	SortStableBy(parts, PersonneNom, false)
	if triGroupe {
		SortStableBy(parts, ParticipantAnimateur, false)
		SortStableBy(parts, ParticipantGroupe, false)
	}
}

// GetListes renvoi la liste des inscrits et la liste d'attente.
// Si `critereBus` est non nul, ne renvoi que les participants matchant ce critère.
// Pour un camp simple, ces critères sont ignorés.
func (ac AccesCamp) GetListes(triGroupe bool, critereBus rd.Bus, hideNonValidated, selectPartageOK bool) (inscrits rd.Table, attente rd.Table) {
	if ac.RawData().InscriptionSimple {
		l := ac.GetParticipantsimples(nil)
		inscrits = make(rd.Table, len(l))
		for i, part := range l {
			inscrits[i] = part.AsItem()
		}
	} else {
		_, cache := ac.Base.ResoudParticipants()
		insc, att := ac.GetInscrits(cache), ac.GetAttente(cache)
		inscrits, attente = make(rd.Table, 0, len(insc)), make(rd.Table, 0, len(att))
		for _, part := range insc {
			if hideNonValidated { // ignore les participants en attente de validation
				if f, ok := part.GetFacture(); ok && !f.RawData().IsValidated {
					continue
				}
			}
			if selectPartageOK {
				// si un participant est lié à un dossier qui n'autorise pas
				// le partage, ignore
				if f, ok := part.GetFacture(); ok && !f.RawData().PartageAdressesOK {
					continue
				}
			}
			if part.RawData().Options.Bus.Match(critereBus) {
				inscrits = append(inscrits, part.AsItem(cache))
			}
		}
		for _, part := range att {
			if hideNonValidated { // ignore les participants en attente de validation
				if f, ok := part.GetFacture(); ok && !f.RawData().IsValidated {
					continue
				}
			}
			if part.RawData().Options.Bus.Match(critereBus) {
				attente = append(attente, part.AsItem(cache))
			}
		}
	}
	TriParticipantsItems(inscrits, triGroupe)
	TriParticipantsItems(attente, triGroupe)
	return inscrits, attente
}

// StatsCamp renvoie un détails du nombre de personnes par catégorie.
func (ac AccesCamp) GetStats(cacheP LiensCampParticipants, cachePs LiensCampParticipantsimples, cacheE LiensCampEquipiers) StatsCamp {
	inscrits, inscritssimples := ac.GetInscrits(cacheP), ac.GetParticipantsimples(cachePs)
	nbInscrits, nbG, nbF := len(inscrits)+len(inscritssimples), 0, 0
	for _, part := range inscrits {
		switch part.GetPersonne().RawData().Sexe {
		case "M":
			nbG += 1
		case "F":
			nbF += 1
		}
	}
	r := ac.RawData()
	return StatsCamp{
		Inscrits:        nbInscrits,
		Attente:         len(ac.GetAttente(cacheP)),
		Equipe:          len(ac.GetEquipe(cacheE)),
		PlacesRestantes: int(r.NbPlaces) - nbInscrits,
		PlacesReservees: int(r.NbPlacesReservees),
		Garcons:         nbG,
		Filles:          nbF,
	}
}

// TrouveGroupe cherche parmis les groupes possibles celui qui pourrait convenir.
// Normalement, les groupes respectent un invariant de continuité sur les plages,
// imposé par le frontend.
// Si plusieurs peuvent convenir, un seul est renvoyé, de façon arbitraire.
func (ac AccesCamp) TrouveGroupe(dateNaissance rd.Date) (rd.Groupe, bool) {
	cg := composites.CampGroupes{Camp: ac.RawData(), Groupes: ac.GetGroupes()}
	return cg.TrouveGroupe(dateNaissance)
}

// GetRegisteredDocuments renvoie les documents (enregistrés sur la base)
// liés au camp.
// Si `withLettre` vaut false, seules les pièces jointes additionnelles sont renvoyés.
// Si `withPiecesJointes` vaut false, seules les lettres sont renvoyés.
func (ac AccesCamp) GetRegisteredDocuments(withLettre, withPiecesJointes bool) (out []rd.Document) {
	for _, lien := range ac.Base.DocumentCamps {
		if lien.IdCamp == ac.Id {
			doc := ac.Base.Documents[lien.IdDocument]
			if (withLettre && lien.IsLettre) || (withPiecesJointes && !lien.IsLettre) {
				out = append(out, doc)
			}
		}
	}
	return out
}

func (ac AccesGroupe) GetCamp() AccesCamp {
	return ac.Base.NewCamp(ac.RawData().IdCamp)
}

func (ac AccesGroupe) AsGroupeCamp() composites.GroupeCamp {
	return composites.GroupeCamp{
		Groupe: ac.RawData(),
		Camp:   ac.GetCamp().RawData(),
	}
}

// Renvoie les ids des contraintes imposées au groupe.
func (ac AccesGroupe) GetContraintes() rd.GroupeContraintes {
	return ac.Base.GroupeContraintes[ac.Id]
}

// Label inclut le nom du camp
func (ac AccesGroupe) Label() rd.String {
	camp := ac.GetCamp()
	out := camp.RawData().Label()
	if len(camp.GetGroupes()) >= 1 {
		out += " - " + ac.RawData().Nom
	}
	return out
}

// --------------------------------------------------------------------------
// ------------------------------- Participant ------------------------------
// --------------------------------------------------------------------------

func (ac AccesParticipant) AsParticipantCamp() composites.ParticipantCamp {
	return composites.ParticipantCamp{
		Participant: ac.RawData(),
		Camp:        ac.GetCamp().RawData(),
	}
}

func (ac AccesParticipant) AsParticipantPersonne() composites.ParticipantPersonne {
	return composites.ParticipantPersonne{
		Participant: ac.RawData(),
		Personne:    ac.GetPersonne().RawData(),
	}
}

func (ac AccesParticipant) GetCamp() AccesCamp {
	return ac.Base.NewCamp(ac.RawData().IdCamp)
}

func (ac AccesParticipant) GetPersonne() AccesPersonne {
	return ac.Base.NewPersonne(ac.RawData().IdPersonne)
}

func (ac AccesParticipant) GetFacture() (AccesFacture, bool) {
	idFac := ac.RawData().IdFacture
	if !idFac.Valid {
		return AccesFacture{}, false
	}
	return ac.Base.NewFacture(idFac.Int64), true
}

func (ac AccesParticipant) GetGroupe() (rd.Groupe, bool) {
	lien, has := ac.Base.ParticipantGroupe[ac.Id]
	if has {
		return ac.Base.NewGroupe(lien.IdGroupe).RawData(), true
	}
	return rd.Groupe{}, false
}

func (ac AccesParticipant) GetAnimateur() (composites.EquipierPersonne, bool) {
	lien, has := ac.Base.ParticipantEquipier[ac.Id]
	if has {
		eq := ac.Base.Equipiers[lien.IdEquipier]
		pers := ac.Base.Personnes[eq.IdPersonne]
		return composites.EquipierPersonne{Equipier: eq, Personne: pers}, true
	}
	return composites.EquipierPersonne{}, false
}

// HintsAttente évalue si le participant devrait être placé
// en liste d'attente ou non.
// Certains critères ne sont pertinents que pour un participant
// actuellement en liste d'attente.
func (ac AccesParticipant) HintsAttente(cache rd.LiensCampParticipants) rd.HintsAttente {
	personne := ac.GetPersonne().RawData()
	isAlreadyInscrit := ac.RawData().ListeAttente.Statut == rd.Inscrit
	return ac.GetCamp().hintsAttente(cache, personne, isAlreadyInscrit)
}

func (ac AccesParticipant) IsAgeValide() bool {
	statusMin, statusMax := ac.GetCamp().RawData().HasAgeValide(ac.GetPersonne().RawData().BasePersonne)
	return statusMin == rd.Inscrit && statusMax == rd.Inscrit
}

// GetAides renvoies les aides liées au participant.
// Si `cache` vaut nil, parcourt la table des aides.
func (ac AccesParticipant) GetAides(cache LiensParticipantAides) []AccesAide {
	if cache == nil {
		cache = ac.Base.ResoudAides()
	}
	ids := cache[ac.Id]
	out := make([]AccesAide, len(ids))
	for index, id := range ids {
		out[index] = ac.Base.NewAide(id)
	}
	return out
}

// StatutPrix renvoi la catégorie de prix du participant
// Une catégorie avec un Id vide équivaut à l'absence de catégorie
func (ac AccesParticipant) StatutPrix() rd.PrixParStatut {
	s := ac.RawData().OptionPrix.Statut
	if s == 0 {
		return rd.PrixParStatut{}
	}
	campOption := ac.GetCamp().RawData().OptionPrix
	if campOption.Active != rd.OptionsPrix.STATUT {
		return rd.PrixParStatut{}
	}
	for _, info := range campOption.Statut {
		if info.Id == s {
			return info
		}
	}
	return rd.PrixParStatut{}
}

type BilanPrixCamp = composites.BilanPrixCamp

// EtatFinancier calcule le prix du sejour pour le participant,
// en prenant en compte les options, les remises et les aides.
// Si `withAidesInvalides` vaut `false`, les aides non validées ne sont pas renvoyées.
func (ac AccesParticipant) EtatFinancier(cache LiensParticipantAides, withAidesInvalides bool) BilanPrixCamp {
	// résolution des données
	fac, _ := ac.GetFacture()
	cp := composites.ParticipantComplet{
		ParticipantCamp: ac.AsParticipantCamp(),
		// zero value si le participant n'a pas de facture
		FacturePersonne: fac.AsFacturePersonne(),
	}
	// résolutions des aides
	var aides []composites.AideStructureaide
	for _, aide := range ac.GetAides(cache) {
		aides = append(aides, aide.WithStructure())
	}
	return cp.EtatFinancier(aides, withAidesInvalides)
}

func (ac AccesParticipant) IsFicheSanitaireUpToDate() rd.OptionnalBool {
	return ac.AsParticipantPersonne().IsFicheSanitaireUpToDate()
}

func (ac AccesParticipant) GetPresence() rd.Plage {
	plage, _ := ac.AsParticipantCamp().AsOptionParticipantCamp().Presence()
	return plage
}

// -------------------------------------------------------------------------

func (ac AccesParticipantsimple) GetCamp() AccesCamp {
	return ac.Base.NewCamp(ac.RawData().IdCamp)
}

func (ac AccesParticipantsimple) GetPersonne() AccesPersonne {
	return ac.Base.NewPersonne(ac.RawData().IdPersonne)
}

// GetPresence renvoie la date d'arrivée et départ du participant
func (ac AccesParticipantsimple) GetPresence() rd.Plage {
	camp := ac.GetCamp().RawData()
	arrivee, depart := camp.DateDebut, camp.DateFin
	return rd.Plage{From: arrivee, To: depart}
}

// AsItemChilds renvoie une stucture hierachique sans enfants
func (ac AccesParticipantsimple) AsItemChilds() rd.ItemChilds {
	item := ac.AsItem()
	return rd.ItemChilds{Item: item}
}

// --------------------------------------------------------------------------
// ----------------------------- Equipier -----------------------------------
// --------------------------------------------------------------------------

func (ac AccesEquipier) GetPersonne() AccesPersonne {
	return ac.Base.NewPersonne(ac.RawData().IdPersonne)
}

func (ac AccesEquipier) GetCamp() AccesCamp {
	return ac.Base.NewCamp(ac.RawData().IdCamp)
}

func (ac AccesEquipier) GetContraintes() rd.EquipierContraintes {
	return ac.Base.EquipierContraintes[ac.Id]
}

func safeChange(date, candidat rd.Date) rd.Date {
	if !candidat.Time().IsZero() {
		return candidat
	}
	return date
}

// GetPresence renvoie la date d'arrivée et départ du participant
// Elles sont déterminés par le champ `Présence`
// (puis par défaut les dates du camp)
func (ac AccesEquipier) GetPresence() rd.Plage {
	camp := ac.GetCamp()
	rawCamp := camp.RawData()

	// plus faible priorité
	arrivee, depart := rawCamp.DateDebut, rawCamp.DateFin

	rawPart := ac.RawData()
	if rawPart.Presence.Active {
		arrivee, depart = safeChange(arrivee, rawPart.Presence.From), safeChange(depart, rawPart.Presence.To)
	}
	return rd.Plage{From: arrivee, To: depart}
}

// --------------------------------------------------------------------------
// ------------------------------- Aide -------------------------------------
// --------------------------------------------------------------------------

func (ac AccesAide) GetStructureaide() AccesStructureaide {
	return ac.Base.NewStructureaide(ac.RawData().IdStructureaide)
}

func (ac AccesAide) GetParticipant() AccesParticipant {
	return ac.Base.NewParticipant(ac.RawData().IdParticipant)
}

func (ac AccesAide) AsAideParticipantCamp() composites.AideParticipantCamp {
	return composites.AideParticipantCamp{
		Aide:            ac.RawData(),
		ParticipantCamp: ac.GetParticipant().AsParticipantCamp(),
	}
}

// ValeurEffective renvoie :
// 	- le montant dans le cas d'une aide absolue
// 	- le montant fois le nombre de jours (en prenant en compte une éventuelle limite) sinon
// Si `withRemise` vaut true les remises (%) sont appliquées.
func (ac AccesAide) ValeurEffective(withRemise bool) rd.Euros {
	return ac.AsAideParticipantCamp().ValeurEffective(withRemise)
}

// GetDocuments renvoie la liste des pièces justificatives associées à l'aide.
func (ac AccesAide) GetDocuments() rd.Table {
	aideToDocs := ac.Base.ResoudDocumentsAides()
	ids := aideToDocs[ac.Id]
	out := make(rd.Table, len(ids))
	for i, id := range ids {
		out[i] = AccesDocumentAide{ac.Base.NewDocument(id)}.AsItem()
	}
	return out
}

func (ac AccesAide) Label() string {
	return ac.GetParticipant().GetPersonne().RawData().NomPrenom().String() + " - " + string(ac.GetStructureaide().RawData().Nom)
}

func (ac AccesAide) Description() string {
	return fmt.Sprintf("%s : %s", ac.GetStructureaide().RawData().Nom, ac.ValeurEffective(false))
}

func (ac AccesAide) WithStructure() composites.AideStructureaide {
	return composites.AideStructureaide{
		Aide:          ac.RawData(),
		Structureaide: ac.GetStructureaide().RawData(),
	}
}

// --------------------------------------------------------------------------
// -------------------------------- Facture ---------------------------------
// --------------------------------------------------------------------------

func (ac AccesFacture) GetPersonne() AccesPersonne {
	return ac.Base.NewPersonne(ac.RawData().IdPersonne)
}

func (ac AccesFacture) AsFacturePersonne() composites.FacturePersonne {
	return composites.FacturePersonne{
		Facture:  ac.RawData(),
		Personne: ac.GetPersonne().RawData(),
	}
}

// GetDossiers renvoie les dossiers associés à la facture.
// Si l'attribut `cache` vaut nil,
// effectue un parcourt de la table des participants.
func (ac AccesFacture) GetDossiers(cache LiensFactureParticipants) []AccesParticipant {
	if cache == nil {
		cache, _ = ac.Base.ResoudParticipants()
	}
	ids := cache[ac.Id]
	out := make([]AccesParticipant, len(ids))
	for index, id := range ids {
		out[index] = ac.Base.NewParticipant(id)
	}
	sort.Slice(out, func(i, j int) bool {
		return out[i].Id < out[j].Id
	})
	return out
}

func (ac AccesFacture) AsItemChilds(cache1 LiensFactureParticipants, cache2 LiensFactureMessages, cache3 LiensFacturePaiements, cache4 LiensCampParticipants) rd.ItemChilds {
	item := ac.AsItem(cache1, cache2, cache3)
	doss := ac.GetDossiers(cache1)
	childs := make(rd.Table, len(doss))
	for index, d := range doss {
		childs[index] = d.AsItem(cache4)
	}
	return rd.ItemChilds{Item: item, Childs: childs}
}

// GetPaiements renvoies les paiements liés à la facture.
// Si l'attribut `cache` vaut nil,
// effectue un parcourt de la table des paiements
func (ac AccesFacture) GetPaiements(cache LiensFacturePaiements, withInvalides bool) []AccesPaiement {
	if cache == nil {
		cache = ac.Base.ResoudPaiements()
	}
	ids := cache[ac.Id]
	out := make([]AccesPaiement, 0, len(ids))
	for _, Id := range ids {
		ac := ac.Base.NewPaiement(Id)
		if withInvalides || bool(!ac.RawData().IsInvalide) {
			out = append(out, ac)
		}
	}
	return out
}

// ChoixDestinataires renvoie les destinataires possibles, y compris
// le responsable, qui est garantit d'être en première position
func (ac AccesFacture) ChoixDestinataires() rd.DestinatairesOptionnels {
	d := ac.GetPersonne().RawData().ToDestinataire()
	others := ac.RawData().DestinatairesOptionnels
	return append(rd.DestinatairesOptionnels{d}, others...)
}

// BilanFacture résume l'état d'une facture.
// (il peut être utilisé pour éviter de répéter les mêmes calculs )
type BilanFacture struct {
	Paiements     []rd.Paiement
	Participants  []AccesParticipant
	Demande, Recu rd.Euros
}

func (b BilanFacture) IsAcquitte() bool {
	return b.Demande.IsLess(b.Recu)
}

func (b BilanFacture) IsExactAcquitte() bool {
	return b.Demande.IsEqual(b.Recu)
}

func (b BilanFacture) ApresPaiement() rd.Euros {
	return b.Demande - b.Recu
}

func (b BilanFacture) StatutPaiement() rd.Completion {
	if b.Participants == nil {
		return rd.Invalide
	}
	if b.IsAcquitte() {
		return rd.Complete
	} else if b.Recu > 0 {
		return rd.EnCours
	} else {
		return rd.NonCommencee
	}
}

type CacheEtatFinancier struct {
	PAides        LiensParticipantAides
	FPaiements    LiensFacturePaiements
	FParticipants LiensFactureParticipants
}

// NewCacheEtatFinancier parcourts les tables des aides, paiements et participants
func (b *BaseLocale) NewCacheEtatFinancier() CacheEtatFinancier {
	var cache CacheEtatFinancier
	cache.PAides = b.ResoudAides()
	cache.FPaiements = b.ResoudPaiements()
	cache.FParticipants, _ = b.ResoudParticipants()
	return cache
}

// EtatFinancier additionne le prix pour chaque participant et
// décompte les paiements effectués. Seuls les participants inscrits (en liste principale)
// sont pris en compte.
// Les participants en liste d'attente sont ignorés.
// `withInvalides` contrôle si les aides et paiements invalides sont affichés ou non.
// Les maps de `cache` sont générés si `nil`
func (ac AccesFacture) EtatFinancier(cache CacheEtatFinancier, withInvalides bool) BilanFacture {
	var out BilanFacture

	if cache.PAides == nil {
		cache.PAides = ac.Base.ResoudAides()
	}

	for _, participant := range ac.GetDossiers(cache.FParticipants) {
		if !participant.RawData().ListeAttente.IsInscrit() {
			continue
		}
		prixParticipant := participant.EtatFinancier(cache.PAides, withInvalides) //
		out.Demande += prixParticipant.PrixNet()
		out.Participants = append(out.Participants, participant)
	}

	for _, paiement := range ac.GetPaiements(cache.FPaiements, false) {
		raw := paiement.RawData()
		if raw.IsRemboursement {
			out.Recu -= raw.Valeur
		} else {
			out.Recu += raw.Valeur
		}
		out.Paiements = append(out.Paiements, raw)
	}
	return out
}

// Camps renvois les camps concernés par la facture, ainsi qu'une description
func (ac AccesFacture) Camps(cache LiensFactureParticipants) (map[int64]bool, string) {
	ids, tmp := make(map[int64]bool), rd.StringSet{}
	for _, doss := range ac.GetDossiers(cache) {
		camp := doss.GetCamp().RawData()
		ids[camp.Id] = true
		tmp[camp.Label().String()] = true
	}
	noms := tmp.ToList()
	sort.Slice(noms, func(i, j int) bool {
		return noms[i] > noms[j]
	})
	return ids, strings.Join(noms, ", ")
}

// participants renvoit les participants
func (ac AccesFacture) participants(cache LiensFactureParticipants) string {
	idsPers := rd.NewSet()
	for _, doss := range ac.GetDossiers(cache) {
		idsPers.Add(doss.GetPersonne().Id)
	}
	var chunks []string
	for id := range idsPers {
		chunks = append(chunks, ac.Base.NewPersonne(id).RawData().NomPrenom().String())
	}
	sort.Strings(chunks) // déterminisme
	return strings.Join(chunks, ", ")
}

// Description renvoie un tableau Html résumant les participants et les
// paiements associés à la facture.
// Les paiements et aides invalides sont affichés.
func (ac AccesFacture) Description() string {
	bilan := ac.EtatFinancier(CacheEtatFinancier{}, true)
	s := "<table cellpadding='5'><tr>"
	for _, header := range headerFacture {
		s += "<th>" + header + "</th>"
	}
	s += "</tr>"
	sepTab := "&nbsp;"
	for _, dossier := range bilan.Participants {
		var row bytes.Buffer
		bilanPrix := dossier.EtatFinancier(nil, true)
		err := templateRowFacture.Execute(&row, dataTemplateFacture{
			Personne:  dossier.GetPersonne().RawData(),
			Camp:      dossier.GetCamp().RawData(),
			BilanPrix: bilanPrix,
		})
		if err == nil {
			s += row.String()
		} else {
			s += "<tr>" + err.Error() + "</tr>"
		}
		rem := bilanPrix.Remises.Description(sepTab)
		sousTotal := bilanPrix.PrixNet().String()
		if len(rem) > 0 {
			s += fmt.Sprintf(`<tr><td colspan="%d" style="text-align: right;">%s</td><td color="blue">%s</td></tr>`,
				len(headerFacture)-1, strings.Join(rem, sepTab), sousTotal)
		}
	}
	s += fmt.Sprintf(`<tr><td colspan=%d style="text-align: right;">%s</td><td><i>%s</i></td></tr>`,
		len(headerFacture)-1, "Total (après remises)", bilan.Demande)
	for _, paiement := range ac.GetPaiements(nil, true) {
		desc, montant := paiement.RawData().Description()
		s += fmt.Sprintf(`<tr><td colspan="2"><td colspan="%d" style="text-align: left;"><a href='%d'>%s</a></td>
			<td>%s</td></tr>`,
			len(headerFacture)-3, paiement.Id, desc, montant)
	}
	s += fmt.Sprintf(`<tr><td colspan=%d style="text-align: right;">%s</td><td><b>%s</b></td></tr>`,
		len(headerFacture)-1, "Total (après paiements)", bilan.ApresPaiement())
	s += "</table>"
	return s
}

// LabelVirement renvoie le label (préfixé) permettant d'identifier le dossier
// lors d'un virement.
func (ac AccesFacture) LabelVirement() string {
	return logs.LabelVirement.Offusc(ac.Id)
}

// NeedAcompte indique si un acompte est demandé sur l'un des camps du dossier.
func (ac AccesFacture) NeedAcompte() bool {
	for _, part := range ac.GetDossiers(nil) {
		if part.GetCamp().RawData().SchemaPaiement == rd.SPAcompte {
			return true
		}
	}
	return false
}

// --------------------------------------------------------------------------
// ------------------------------ Paiement ----------------------------------
// --------------------------------------------------------------------------
func (ac AccesPaiement) GetFacture() AccesFacture {
	return ac.Base.NewFacture(ac.RawData().IdFacture)
}

// --------------------------------------------------------------------------
// ------------------------------ Document ----------------------------------
// --------------------------------------------------------------------------

type AccesDocumentPersonne struct {
	AccesDocument
}

func (b *BaseLocale) NewDocumentPersonne(id int64) AccesDocumentPersonne {
	return AccesDocumentPersonne{b.NewDocument(id)}
}

// GetContrainte renvoie la contrainte pour un document
// attaché à une personne
func (ac AccesDocumentPersonne) GetContrainte() rd.Contrainte {
	lien := ac.Base.DocumentPersonnes[ac.Id]
	return ac.Base.Contraintes[lien.IdContrainte]
}

func (ac AccesDocumentPersonne) GetProprietaire() AccesPersonne {
	lien := ac.Base.DocumentPersonnes[ac.Id]
	return ac.Base.NewPersonne(lien.IdPersonne)
}

type AccesDocumentAide struct {
	AccesDocument
}

func (ac AccesDocumentAide) GetAide() AccesAide {
	lien := ac.Base.DocumentAides[ac.Id]
	return ac.Base.NewAide(lien.IdAide)
}

// --------------------------------------------------------------------------
// --------------------------------- Don ------------------------------------
// --------------------------------------------------------------------------

// PersonneOrganisme regroupe les éléments affichés
// dans la liste des personnes : personne ou organisme
type PersonneOrganisme interface {
	// CoordonneesDons renvoie les coordonnées utilisées
	// pour un don.
	CoordonneesDons() rd.Coordonnees
}

// CoordonneesDons renvoie les coordonnées de la personne
func (ac AccesPersonne) CoordonneesDons() rd.Coordonnees {
	return ac.RawData().Coordonnees()
}

// CoordonneesDons choisit en priorité le contact spécifique aux dons,
// puis le contact normal (propre ou non).
func (ac AccesOrganisme) CoordonneesDons() rd.Coordonnees {
	raw := ac.RawData()
	if cd := raw.IdContactDon; cd.IsNotNil() {
		return ac.Base.Personnes[cd.Int64].Coordonnees()
	} else if c := raw.IdContact; c.IsNotNil() {
		return ac.Base.Personnes[c.Int64].Coordonnees()
	} else {
		return raw.Contact
	}
}

// GetDonateur renvoie le donateur, possiblement nil
func (ac AccesDon) GetDonateur() PersonneOrganisme {
	donateur := ac.Base.DonDonateurs[ac.Id]
	switch id := donateur.IId().(type) {
	case rd.IdPersonne:
		return ac.Base.NewPersonne(id.Int64())
	case rd.IdOrganisme:
		return ac.Base.NewOrganisme(id.Int64())
	default:
		return nil
	}
}