probe

var ButtonImplFileFieldFieldSubTemplateCode map[ButtonImplSubTemplateId]string = map[ButtonImplSubTemplateId]string{

	ButtonImplSubTmplBasicField: `
		BasicFieldtoForm("{{FieldName}}", instanceWithInferedType.{{FieldName}}, instanceWithInferedType, probe.formStage, formGroup,
			{{isTextArea}}, {{isBespokeWidth}}, {{bespokeWidth}}, {{isBespokeHeight}}, {{bespokeHeight}})`,
	ButtonImplSubTmplBasicFieldEnumString: `
		EnumTypeStringToForm("{{FieldName}}", instanceWithInferedType.{{FieldName}}, instanceWithInferedType, probe.formStage, formGroup)`,
	ButtonImplSubTmplBasicFieldEnumInt: `
		EnumTypeIntToForm("{{FieldName}}", instanceWithInferedType.{{FieldName}}, instanceWithInferedType, probe.formStage, formGroup)`,
	ButtonImplSubTmplPointerField: `
		AssociationFieldToForm("{{FieldName}}", instanceWithInferedType.{{FieldName}}, formGroup, probe)`,
	ButtonImplSubTmplSliceOfPointersField: `
		AssociationSliceToForm("{{FieldName}}", instanceWithInferedType, &instanceWithInferedType.{{FieldName}}, formGroup, probe)`,
	ButtonImplSubTmplSliceOfPointersReversePointer: `
		{
			var rf models.ReverseField
			_ = rf
			rf.GongstructName = "{{AssocStructName}}"
			rf.Fieldname = "{{FieldName}}"
			reverseFieldOwner := models.GetReverseFieldOwner(probe.stageOfInterest, instanceWithInferedType, &rf)
			if reverseFieldOwner != nil {
				AssociationReverseFieldToForm(
					reverseFieldOwner.(*models.{{AssocStructName}}),
					"{{FieldName}}",
					instanceWithInferedType,
					formGroup,
					probe)
			} else {
				AssociationReverseFieldToForm[*models.{{AssocStructName}}](
					nil,
					"{{FieldName}}",
					instanceWithInferedType,
					formGroup,
					probe)
			}
		}`,
}

var FillUpFormFromGongstructNameSubTemplateCode map[string]string = map[string]string{
	string(rune(FillUpTreeStructCase)): `
	case "{{Structname}}":
		formGroup := (&form.FormGroup{
			Name:  FormName,
			Label: prefix + "{{Structname}} Form",
		}).Stage(formStage)
		formGroup.OnSave = __gong__New__{{Structname}}FormCallback(
			nil,
			probe,
			formGroup,
		)
		{{structname}} := new(models.{{Structname}})
		formGroup.HasSuppressButton = !isNewInstance
		FillUpForm({{structname}}, formGroup, probe)`,
}

var FillUpFormFromGongstructSubTemplateCode map[string]string = map[string]string{
	string(rune(FillUpTreeStructCase)): `
	case *models.{{Structname}}:
		formGroup := (&gongtable.FormGroup{
			Name:  formName,
			Label: "{{Structname}} Form",
		}).Stage(formStage)
		formGroup.OnSave = __gong__New__{{Structname}}FormCallback(
			instancesTyped,
			probe,
			formGroup,
		)
		formGroup.HasSuppressButton = true
		FillUpForm(instancesTyped, formGroup, probe)`,
}

var FillUpFormSubTemplateCode map[FillUpFormInsertionId]string = map[FillUpFormInsertionId]string{
	ButtonImplPerGongstructCallToFormGenerator: `
	case *models.{{Structname}}:
		// insertion point{{fieldToFormCode}}
`,
}

var FillUpTableSubTemplateCode map[string]string = map[string]string{

	string(rune(FillUpTableCaseForCastingDown)): `
	case *models.{{Structname}}:
		updateAndCommitTable[models.{{Structname}}](probe)`,
	string(rune(FillUpTableCase)): `
	case *models.{{Structname}}:
		formGroup := (&gongtable.FormGroup{
			Name:  FormName,
			Label: "Update {{Structname}} Form",
			OnSave: __gong__New__{{Structname}}FormCallback(
				instancesTyped,
				rowUpdate.probe,
			),
		}).Stage(formStage)
		FillUpForm(instancesTyped, formGroup, rowUpdate.probe)`,
	string(rune(FillUpTableCaseForDeleteIcon)): `
	case *models.{{Structname}}:
		instancesTyped.Unstage(cellDeleteIconImpl.probe.stageOfInterest)`,
}

var FillUpTreeSubTemplateCode map[string]string = map[string]string{
	string(rune(FillUpTreeStructCase)): `
		case "{{Structname}}":
			nodeGongstruct.Name = name
			set := *models.GetGongstructInstancesSetFromPointerType[*models.{{Structname}}](probe.stageOfInterest)
			created := 0
			updated := 0
			deleted := 0
			for _{{structname}} := range set {
				nodeInstance := &tree.Node{Name: _{{structname}}.GetName()}
				nodeInstance.IsNodeClickable = true
				nodeInstance.Impl = NewInstanceNodeCallback(_{{structname}}, "{{Structname}}", probe)

				nodeGongstruct.Children = append(nodeGongstruct.Children, nodeInstance)
				if _, ok := probe.stageOfInterest.GetNew()[_{{structname}}]; ok {
					created++
				}
				if _, ok := probe.stageOfInterest.GetModified()[_{{structname}}]; ok {
					updated++
				}
				if _, ok := probe.stageOfInterest.GetDeleted()[_{{structname}}]; ok {
					deleted++
				}
			}
			nodeGongstruct.Name += fmt.Sprintf(" (%d/%d/%d)", created, updated, deleted)`,
}

var FormCallbackFileFieldFieldSubTemplateCode map[FormCallbackSubTemplateId]string = map[FormCallbackSubTemplateId]string{

	FormCallbackSubTmplBasicField: `
		case "{{FieldName}}":
			FormDivBasicFieldToField(&({{structname}}_.{{FieldName}}), formDiv)`,
	FormCallbackSubTmplBasicFieldEnumString: `
		case "{{FieldName}}":
			FormDivEnumStringFieldToField(&({{structname}}_.{{FieldName}}), formDiv)`,
	FormCallbackSubTmplBasicFieldEnumInt: `
		case "{{FieldName}}":
			FormDivEnumIntFieldToField(&({{structname}}_.{{FieldName}}), formDiv)`,
	FormCallbackSubTmplPointerToStruct: `
		case "{{FieldName}}":
			FormDivSelectFieldToField(&({{structname}}_.{{FieldName}}), {{structname}}FormCallback.probe.stageOfInterest, formDiv)`,
	FormCallbackSubTmplSliceOfPointers: `
		case "{{FieldName}}":
			instanceSet := *models.GetGongstructInstancesSetFromPointerType[*models.{{AssocStructName}}]({{structname}}FormCallback.probe.stageOfInterest)
			instanceSlice := make([]*models.{{AssocStructName}}, 0)

			// make a map of all instances by their ID
			map_id_instances := make(map[uint]*models.{{AssocStructName}})

			for instance := range instanceSet {
				id := models.GetOrderPointerGongstruct(
					{{structname}}FormCallback.probe.stageOfInterest,
					instance,
				)
				map_id_instances[id] = instance
			}

			ids, err := DecodeStringToIntSlice(formDiv.FormEditAssocButton.AssociationStorage)

			if err != nil {
				log.Panic("not a good storage", formDiv.FormEditAssocButton.AssociationStorage)
			}
			for _, id := range ids {
				instanceSlice = append(instanceSlice, map_id_instances[id])
			}
			{{structname}}_.{{FieldName}} = instanceSlice
`,
	FormCallbackSubTmplSliceOfPointersReversePointer: `
		case "{{AssocStructName}}:{{FieldName}}":
			// WARNING : this form deals with the N-N association "{{AssocStructName}}.{{FieldName}} []*{{Structname}}" but
			// it work only for 1-N associations (TODO: #660, enable this form only for field with //gong:1_N magic code)
			//
			// In many use cases, for instance tree structures, the assocation is semanticaly a 1-N
			// association. For those use cases, it is handy to set the source of the assocation with
			// the form of the target source (when editing an instance of {{Structname}}). Setting up a value
			// will discard the former value is there is one.
			//
			// Therefore, the forms works only in ONE particular case:
			// - there was no association to this target
			var formerSource *models.{{AssocStructName}}
			{
				var rf models.ReverseField
				_ = rf
				rf.GongstructName = "{{AssocStructName}}"
				rf.Fieldname = "{{FieldName}}"
				formerAssociationSource := models.GetReverseFieldOwner(
					{{structname}}FormCallback.probe.stageOfInterest,
					{{structname}}_,
					&rf)

				var ok bool
				if formerAssociationSource != nil {
					formerSource, ok = formerAssociationSource.(*models.{{AssocStructName}})
					if !ok {
						log.Fatalln("Source of {{AssocStructName}}.{{FieldName}} []*{{Structname}}, is not an {{AssocStructName}} instance")
					}
				}
			}

			newSourceName := formDiv.FormFields[0].FormFieldSelect.Value

			// case when the user set empty for the source value
			if newSourceName == nil {
				// That could mean we clear the assocation for all source instances
				if formerSource != nil {
					idx := slices.Index(formerSource.{{FieldName}}, {{structname}}_)
					formerSource.{{FieldName}} = slices.Delete(formerSource.{{FieldName}}, idx, idx+1)
				}
				break // nothing else to do for this field
			}

			// the former source is not empty. the new value could
			// be different but there mught more that one source thet
			// points to this target
			if formerSource != nil {
				break // nothing else to do for this field
			}

			// (2) find the source
			var newSource *models.{{AssocStructName}}
			for _{{assocStructName}} := range *models.GetGongstructInstancesSet[models.{{AssocStructName}}]({{structname}}FormCallback.probe.stageOfInterest) {

				// the match is base on the name
				if _{{assocStructName}}.GetName() == newSourceName.GetName() {
					newSource = _{{assocStructName}} // we have a match
					break
				}
			}
			if newSource == nil {
				log.Println("Source of {{AssocStructName}}.{{FieldName}} []*{{Structname}}, with name", newSourceName, ", does not exist")
				break
			}

			// (3) append the new value to the new source field
			newSource.{{FieldName}} = append(newSource.{{FieldName}}, {{structname}}_)`,
}

var FormCallbackGongstructSubTemplateCode map[FormCallbackGongstructInsertionId]string = map[FormCallbackGongstructInsertionId]string{
	FormCallbackPerGongstructCode: `
func __gong__New__{{Structname}}FormCallback(
	{{structname}} *models.{{Structname}},
	probe *Probe,
	formGroup *table.FormGroup,
) ({{structname}}FormCallback *{{Structname}}FormCallback) {
	{{structname}}FormCallback = new({{Structname}}FormCallback)
	{{structname}}FormCallback.probe = probe
	{{structname}}FormCallback.{{structname}} = {{structname}}
	{{structname}}FormCallback.formGroup = formGroup

	{{structname}}FormCallback.CreationMode = ({{structname}} == nil)

	return
}

type {{Structname}}FormCallback struct {
	{{structname}} *models.{{Structname}}

	// If the form call is called on the creation of a new instnace
	CreationMode bool

	probe *Probe

	formGroup *table.FormGroup
}

func ({{structname}}FormCallback *{{Structname}}FormCallback) OnSave() {

	// log.Println("{{Structname}}FormCallback, OnSave")

	// checkout formStage to have the form group on the stage synchronized with the
	// back repo (and front repo)
	{{structname}}FormCallback.probe.formStage.Checkout()

	if {{structname}}FormCallback.{{structname}} == nil {
		{{structname}}FormCallback.{{structname}} = new(models.{{Structname}}).Stage({{structname}}FormCallback.probe.stageOfInterest)
	}
	{{structname}}_ := {{structname}}FormCallback.{{structname}}
	_ = {{structname}}_

	for _, formDiv := range {{structname}}FormCallback.formGroup.FormDivs {
		switch formDiv.Name {
		// insertion point per field{{fieldToFormCode}}
		}
	}

	// manage the suppress operation
	if {{structname}}FormCallback.formGroup.HasSuppressButtonBeenPressed {
		{{structname}}_.Unstage({{structname}}FormCallback.probe.stageOfInterest)
	}

	{{structname}}FormCallback.probe.stageOfInterest.Commit()
	updateAndCommitTable[*models.{{Structname}}](
		{{structname}}FormCallback.probe,
	)
	{{structname}}FormCallback.probe.tableStage.Commit()

	// display a new form by reset the form stage
	if {{structname}}FormCallback.CreationMode || {{structname}}FormCallback.formGroup.HasSuppressButtonBeenPressed {
		{{structname}}FormCallback.probe.formStage.Reset()
		newFormGroup := (&table.FormGroup{
			Name: FormName,
		}).Stage({{structname}}FormCallback.probe.formStage)
		newFormGroup.OnSave = __gong__New__{{Structname}}FormCallback(
			nil,
			{{structname}}FormCallback.probe,
			newFormGroup,
		)
		{{structname}} := new(models.{{Structname}})
		FillUpForm({{structname}}, newFormGroup, {{structname}}FormCallback.probe)
		{{structname}}FormCallback.probe.formStage.Commit()
	}

	updateAndCommitTree({{structname}}FormCallback.probe)
}`,
}

var TreeNodeImplGongstructSubTemplateCode map[string]string = map[string]string{
	string(rune(NodeImplGongstruct)): `
	if nodeImplGongstruct.gongStruct.GetName() == "{{Structname}}" {
		updateAndCommitTable[*models.{{Structname}}](nodeImplGongstruct.probe)
	}`,
}