path: root/generate.go

// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
// Use of this source code is governed by the GPL 3.0

package main

import (
	"fmt"
	"io"
	"os"

	"go.wit.com/log"
	"golang.org/x/text/cases"
	"golang.org/x/text/language"
)

// this file is named poorly. It has more than Sort()

func (pb *Files) makeNewSortfile(pf *File) error {
	wSort, _ := os.OpenFile(pf.Filebase+".sort.pb.go", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
	defer wSort.Close()

	header(wSort, pf)
	pf.syncLock(wSort)
	if os.Getenv("PROTOBUF_REGRET") != "true" {
		pf.addNewFunc(wSort)
	}

	fmt.Fprintf(wSort, "// START SORT\n")
	fmt.Fprintf(wSort, "\n")

	// add iterators for all the structs to be used
	for _, msg := range pf.allMsg() {
		funcdef := newScannerDefines(wSort, msg)
		log.Printf("Adding %s\n", funcdef)
	}

	// log.Printf("START COMPARE\n")
	for _, msg := range pf.allMsg() {
		PARENT := msg.Name
		for _, v := range msg.Vars {
			if !v.HasSort {
				continue
			}
			if v.IsRepeated {
				// can't work against slices
				continue
			}
			if v.VarType != "string" {
				continue
			}
			VARNAME := v.VarName
			funcdef := msg.newSortType(wSort, PARENT, VARNAME)
			log.Printf("Adding %s\n", funcdef)
		}
	}

	// add selectAll() functions for all the sort combinations that will be used
	for _, s := range pf.ToSort {
		// log.Printf("SORT: %-2d %20s %20s %20s %20s\n", i, s.MsgName, s.VarType, s.VarName, s.Lockname)
		FRUIT := s.MsgName
		APPLE := s.VarType
		APPLES := s.VarName
		LOCK := s.Lockname

		msg := pf.findMsg(s.MsgName)
		if msg == nil {
			return fmt.Errorf("failed to find struct %s", s.VarType)
		}

		funcdef := msg.newScannerAll(wSort, FRUIT, APPLE, APPLES, LOCK)
		log.Printf("Adding %s\n", funcdef)
	}

	// log.Printf("START SELECT\n")
	// make the sort iterators selectAll()
	for _, s := range pf.ToSort {
		PARENT := s.MsgName
		CHILD := s.VarType
		VARNAME := s.VarName
		LOCK := s.Lockname

		msg := pf.findMsg(s.MsgName)
		if msg == nil {
			return fmt.Errorf("failed to find struct %s", s.VarType)
		}

		funcdef := msg.addSelectAll(wSort, PARENT, CHILD, VARNAME, LOCK)
		log.Printf("Adding %s\n", funcdef)
	}
	// log.Printf("END SELECT\n")

	// log.Printf("START SORT\n")
	// make the SortBy() functions
	for _, s := range pf.ToSort {
		// var funcname string
		PARENT := s.MsgName
		VARNAME := s.VarName

		pmsg := pf.findMsg(s.MsgName)
		if pmsg == nil {
			return fmt.Errorf("failed to find struct %s", s.MsgName)
		}

		msg := pf.findMsg(s.VarType)
		if msg == nil {
			return fmt.Errorf("failed to find struct %s", s.VarType)
		}

		for _, v := range msg.Vars {
			if v.IsRepeated {
				// can't work against slices
				continue
			}
			if v.HasSort {
				// funcname := "func (x *" + FUNCTYPE + ") SortBy" + v.VarName + "(" + v.VarType + ") *[]iter" + s.VarType
				// log.Printf("      %-2s %20s %20s %20s %s %s\n", "", "", "fix", "", "", funcname)
				// funcdef := "func (x *"+FRUIT+") SortBy"+COLOR+"() *"+APPLE+"Iterator"

				if v.VarType == "string" {
					var sortby string
					// func newSortBy(w io.Writer, STRUCT, ITER, SORTNAME, SORTBY, SELECT string) string {
					if PARENT == VARNAME {
						sortby = "SortBy" + v.VarName
						sortname := "sort" + s.VarType + v.VarName
						selectName := "selectAll" + VARNAME
						funcdef := pmsg.newSortBy(wSort, PARENT, s.VarType, sortname, sortby, selectName, v.VarName)
						log.Printf("Adding %s\n", funcdef)

						FRUITS := PARENT
						FRUIT := s.VarType
						SORTNAME := sortname
						BRAND := v.VarName
						funcdef = pmsg.addIterBy(wSort, FRUITS, FRUIT, BRAND, SORTNAME)
						log.Printf("Adding %s\n", funcdef)

						funcname := "Sort" + v.VarName
						STRUCT := PARENT
						LOCK := s.Lockname
						funcdef = pmsg.newSort(wSort, STRUCT, funcname, sortname, LOCK)
						log.Printf("Adding %s\n", funcdef)
					} else {
						// deprecate this THIS DOES NOT MAKE SENSE TO DO
						sortby = "Sort" + VARNAME + "By" + v.VarName
					}
				} else {
					// funcdef := "func (x *" + FUNCTYPE + ") SortBy" + v.VarName + "(" + v.VarType + ") *[]iter" + s.VarType + " # can not do this yet"
				}
			}
		}
	}

	fmt.Fprintf(wSort, "\n")
	fmt.Fprintf(wSort, "// END SORT\n")

	// make Len() and Append()
	for _, msg := range pf.allMsg() {
		PARENT := msg.Name
		LOCK := msg.Lockname

		for _, v := range msg.Vars {
			if v.IsRepeated {
				VARNAME := v.VarName
				// funcdef := "func (x *" + PARENT + ") Len" + VARNAME + "() int " + CHILD + " name:" + VARNAME

				if PARENT == VARNAME {
					// special case
					funcdef := msg.addLenFunc(wSort, PARENT, VARNAME, LOCK) // + " " + v.VarType + " name:" + v.VarName
					funcdef += "  # is special struct=varname"
					log.Printf("Adding %s\n", funcdef)
				}
				if PARENT == VARNAME {
					// FUNCNAME := "Append"
					funcdef := msg.simpleAppend(wSort, PARENT, v.VarName, v.VarType)
					log.Printf("Adding %s\n", funcdef)
					// funcdef := msg.addAppendBy(wSort, PARENT, FUNCNAME, VARNAME, PARENT, s.VarType)
					// log.Printf("      %-2s %20s %20s %20s %s %s\n", "", "", "", "done", "", funcdef)
				}
			}
		}
	}

	// add All()
	for _, s := range pf.ToSort {
		PARENT := s.MsgName
		CHILD := s.VarType
		VARNAME := s.VarName

		// log.Printf("TO SORT IterAll() PARENT==VARNAME? PARENT=%s CHILD=%s VARNAME=%s (%v)\n", PARENT, CHILD, VARNAME, pf.ToSort)
		pmsg := pf.findMsg(PARENT)
		if pmsg == nil {
			// log.Printf("FAILED TO ADD SORT pmsg=nil PARENT=%s CHILD=%s VARNAME=%s\n", PARENT, CHILD, VARNAME)
			return fmt.Errorf("failed to find struct %s", s.MsgName)
		}

		if PARENT == VARNAME {
			funcdef := pmsg.addAllFunc(wSort, PARENT, CHILD, VARNAME)
			log.Printf("Adding %s\n", funcdef)

			FRUITS := PARENT
			FRUIT := CHILD
			funcdef = pmsg.addIterAll(wSort, FRUITS, FRUIT)
			log.Printf("Adding %s\n", funcdef)
		} else {
			// log.Printf("FAILED TO ADD SORT IterAll() PARENT != VARNAME PARENT=%s CHILD=%s VARNAME=%s\n", PARENT, CHILD, VARNAME)
		}

		/*
			// todo: figure out how to do more All() functions correction
			var FUNCTYPE string
			if PARENT == VARNAME {
				FUNCTYPE = PARENT
			} else {
				FUNCTYPE = VARNAME
			}

			if s.VarType+"s" == s.VarName {
				funcname = "func (x *" + FUNCTYPE + ") All() *[]iter" + s.VarType
			} else {
				funcname = "func (x *" + FUNCTYPE + ") all" + s.VarName + "() *[]iter" + s.VarType
			}
			log.Printf("      %-2s %20s %20s %20s %s %s\n", "", "", "", "", "", funcname)
		*/
	}

	// add Delete()
	for _, s := range pf.ToSort {
		PARENT := s.MsgName
		CHILD := s.VarType
		VARNAME := s.VarName

		pmsg := pf.findMsg(s.MsgName)
		if pmsg == nil {
			return fmt.Errorf("failed to find struct %s", s.MsgName)
		}

		if PARENT == VARNAME {
			funcdef := pmsg.addDeleteFunc(wSort, PARENT, VARNAME, CHILD)
			log.Printf("Adding %s\n", funcdef)
		}
	}

	// add Find() Delete() Append() Insert()
	for _, s := range pf.ToSort {
		PARENT := s.MsgName
		VARNAME := s.VarName

		if PARENT != VARNAME {
			// this does not conform to the autogenpb standard format
			continue
		}
		// special case because of the enforced .proto format // ONLY SUPPORT THIS

		pmsg := pf.findMsg(s.MsgName)
		if pmsg == nil {
			return fmt.Errorf("failed to find struct %s", s.MsgName)
		}

		msg := pf.findMsg(s.VarType)
		if msg == nil {
			return fmt.Errorf("failed to find struct %s", s.VarType)
		}

		// find()
		for _, v := range msg.Vars {
			if !(v.VarType == "string" || (v.VarType == "int64")) {
				continue
			}
			if v.IsRepeated {
				continue
			}
			if v.HasUnique {
				// funcname = "func (x *" + PARENT + ") Find" + VARNAME + "By" + v.VarName + "(a " + v.VarType + ") *" + s.VarType + "(using" + v.VarName + ")"
				// log.Printf("      %-2s %20s %20s %20s %s %s\n", "", "", "", "", "", funcname)
				var FUNCNAME string
				if PARENT == VARNAME {
					// special case because of the enforced .proto format
					FUNCNAME = "FindBy" + v.VarName
					funcdef := pmsg.generateFindBy(wSort, FUNCNAME, PARENT, s, v)
					log.Printf("Adding %s\n", funcdef)

					FRUITS := PARENT
					FRUIT := s.VarType
					APPLE := v.VarName
					COLOR := v.VarType
					funcdef = pmsg.insertBy(wSort, FRUITS, FRUIT, APPLE, COLOR)
					log.Printf("Adding %s\n", funcdef)
				}
			} else {
				if v.VarType == "string" {
					// probably dumb. move to a database if you need this
					// funcname = "func (x *" + PARENT + ") Find" + VARNAME + "By" + v.VarName + "(a string) []*" + s.VarType + "  ???"
					// log.Printf("      %-2s %20s %20s %20s %s %s\n", "", "", "", "", "", funcname)
				}
			}
		}

		// delete() functions
		for _, v := range msg.Vars {
			if v.VarType != "string" {
				continue
			}
			if v.IsRepeated {
				continue
			}
			if !v.HasUnique {
				continue
			}
			// funcname := "func (x *" + PARENT + ") Delete" + VARNAME + "By" + v.VarName + "(" + v.VarType + ") bool"
			// log.Printf("      %-2s %20s %20s %20s %s %s\n", "", "", "", "", "", funcname)
			FRUIT := PARENT
			APPLES := VARNAME
			APPLE := v.VarName
			COLOR := v.VarType
			var FUNCNAME string
			if PARENT == VARNAME {
				// special case because of the enforced .proto format // ONLY USE CASE THAT MAKES SENSE
				FUNCNAME = "DeleteBy" + v.VarName
				var funcdef string
				if argv.Delete {
					funcdef = pmsg.deleteByWithCopy(wSort, FRUIT, APPLES, APPLE, COLOR, FUNCNAME, v.VarName)
				} else {
					funcdef = pmsg.deleteBy(wSort, FRUIT, APPLES, APPLE, COLOR, FUNCNAME, v.VarName)
				}
				log.Printf("Adding %s\n", funcdef)
			} else {
				// deprecate these
				FUNCNAME = "Delete" + VARNAME + "By" + v.VarName
			}
		}

		// AppendBy() functions. todo: fix these so Append() is for simple things and Insert() is for unique keys
		var ucount int
		for _, v := range msg.Vars {
			if v.VarType != "string" {
				continue
			}
			if v.IsRepeated {
				continue
			}
			if !v.HasUnique {
				continue
			}
			ucount += 1
			var FUNCNAME string
			if PARENT == VARNAME {
				// special case because of the enforced .proto format // ONLY SUPPORT THIS
				FUNCNAME = "AppendBy" + v.VarName
				funcdef := pmsg.simpleAppendBy(wSort, PARENT, FUNCNAME, VARNAME, v.VarName, s.VarType)
				log.Printf("Adding %s\n", funcdef)
			}
		}

		// TODO: do this next // x *Repos) InsertPath( string) *Repo  // returns existing record or new record if path != exists
		if ucount == 1 {
			for _, v := range msg.Vars {
				if !v.HasUnique {
					continue
				}
				//funcname = "func (x *" + PARENT + ") Insert(a *" + v.VarType + ") (*" + CHILD + ", isNew bool) // todo"
				//log.Printf("%20s %s\n", "", funcdef)
			}
		}
		if ucount > 1 {
			//funcname = "func (x *" + PARENT + ") Insert(a *" + CHILD + ") (*" + CHILD + ", isNew bool) // todo"
			//log.Printf("%20s %s\n", "", funcdef)
		}
	}
	return nil
}

func (pf *File) findMsg(s string) *MsgName {
	if pf.Bases.Name == s {
		return pf.Bases
	}
	if pf.Base.Name == s {
		return pf.Base
	}
	for _, msg := range pf.MsgNames {
		if msg.Name == s {
			return msg
		}
	}
	return nil
}

func (pf *File) allMsg() []*MsgName {
	var all []*MsgName
	all = append(all, pf.Bases)
	all = append(all, pf.Base)
	for _, msg := range pf.MsgNames {
		all = append(all, msg)
	}
	return all
}

func (pf *File) specialBases(wFind io.Writer) {
	var FRUIT string = cases.Title(language.English, cases.NoLower).String(pf.Bases.Name)
	var APPLES string = cases.Title(language.English, cases.NoLower).String(pf.Bases.Name)
	var APPLE string = cases.Title(language.English, cases.NoLower).String(pf.Base.Name)

	pf.Bases.simpleAppend(wFind, FRUIT, APPLES, APPLE)

}