pkg

var AllCommands = []Command{
	AddColumn{},
	CreateDatabase{},
	CreateForeignKeyConstraint{},
	CreateIndex{},
	CreateSchema{},
	CreateTable{},
	DropColumn{},
	DropDatabase{},
	DropForeignKeyConstraint{},
	DropIndex{},
	DropSchema{},
	DropTable{},
	RenameDatabase{},
	RenameSchema{},
	RenameTable{},
}

var Generators = map[reflect.Type]func(*dag.Graph) Command{

	reflect.TypeOf(DropDatabase{}): func(g *dag.Graph) Command { return DropDatabase{dag.Nodes[*Database](g).Any()} },
	reflect.TypeOf(DropIndex{}):    func(g *dag.Graph) Command { return DropIndex{dag.Nodes[*Index](g).Any()} },
	reflect.TypeOf(DropSchema{}):   func(g *dag.Graph) Command { return DropSchema{dag.Nodes[*Schema](g).Any()} },
	reflect.TypeOf(DropTable{}):    func(g *dag.Graph) Command { return DropTable{dag.Nodes[*Table](g).Any()} },

	reflect.TypeOf(CreateDatabase{}): func(g *dag.Graph) Command {

		if len(dag.Nodes[*Database](g)) > 5 {
			return nil
		}
		return CreateDatabase{Name: RandomString()}
	},
	reflect.TypeOf(CreateSchema{}): func(g *dag.Graph) Command {

		if len(dag.Nodes[*Schema](g)) > 2 {
			return nil
		}
		return CreateSchema{Database: dag.Nodes[*Database](g).Any(), Name: RandomString()}
	},
	reflect.TypeOf(CreateTable{}): func(g *dag.Graph) Command {
		return CreateTable{
			Schema: dag.Nodes[*Schema](g).Any(),
			Name:   RandomString(),
		}
	},
	reflect.TypeOf(CreateIndex{}): func(g *dag.Graph) Command {
		table := dag.Nodes[*Table](g, func(t *Table) bool {
			return len(t.Columns()) > 1
		}).Any()
		return CreateIndex{
			Table:   table,
			Name:    RandomString(),
			Columns: table.Columns().PickUpTo(3),
			Unique:  FlipCoin(),
		}
	},

	reflect.TypeOf(RenameTable{}): func(g *dag.Graph) Command {
		return RenameTable{
			Table: dag.Any[*Table](g),
			Name:  RandomString(),
		}
	},
	reflect.TypeOf(RenameSchema{}): func(g *dag.Graph) Command {
		return RenameSchema{
			Schema: dag.Any[*Schema](g, NotPublic),
			Name:   RandomString(),
		}
	},
	reflect.TypeOf(RenameDatabase{}): func(g *dag.Graph) Command {
		return RenameDatabase{
			Database: dag.Any[*Database](g),
			Name:     RandomString(),
		}
	},

	reflect.TypeOf(DropColumn{}):               func(g *dag.Graph) Command { return DropColumn{dag.Nodes[*Column](g).Any()} },
	reflect.TypeOf(DropForeignKeyConstraint{}): func(g *dag.Graph) Command { panic("not implemented") },
	reflect.TypeOf(AddColumn{}): func(g *dag.Graph) Command {
		return AddColumn{
			Table:    dag.Nodes[*Table](g).Any(),
			Name:     RandomString(),
			Nullable: false,
		}
	},
	reflect.TypeOf(CreateForeignKeyConstraint{}): func(g *dag.Graph) Command {

		to := dag.Nodes[*Index](g, func(i *Index) bool {
			return i.Unique && len(i.Columns()) == 1
		}).Any().Columns()[0]

		from := dag.Nodes[*Column](g, func(c *Column) bool {
			return c.Table().Schema().Database() == to.Table().Schema().Database() && c.Table() != to.Table()
		}).Any()

		return CreateForeignKeyConstraint{
			Name: RandomString(),
			From: from,
			To:   to,
		}
	},
}

var Weights = map[reflect.Type]int{
	reflect.TypeOf(CreateIndex{}):  3,
	reflect.TypeOf(AddColumn{}):    3,
	reflect.TypeOf(CreateTable{}):  2,
	reflect.TypeOf(DropDatabase{}): 0,
	reflect.TypeOf(DropColumn{}):   0,
	reflect.TypeOf(DropTable{}):    0,
	reflect.TypeOf(DropSchema{}):   0,
}