// Copyright 2025 Dolthub, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package plpgsql

import (
	"fmt"
	"strconv"
	"strings"

	"github.com/cockroachdb/errors"
)

// action exists to match the expected JSON format.
type action struct {
	StmtBlock plpgSQL_stmt_block `json:"PLpgSQL_stmt_block"`
}

// cond exists to match the expected JSON format.
type cond struct {
	Expression plpgSQL_expr `json:"PLpgSQL_expr"`
}

// datatype exists to match the expected JSON format.
type datatype struct {
	Type plpgSQL_type `json:"PLpgSQL_type"`
}

// default_val exists to match the expected JSON format.
type default_val struct {
	Var plpgSQL_expr `json:"PLpgSQL_expr"`
}

// datum exists to match the expected JSON format.
type datum struct {
	Record      *plpgSQL_rec      `json:"PLpgSQL_rec"`
	RecordField *plpgSQL_recfield `json:"PLpgSQL_recfield"`
	Row         *plpgSQL_row      `json:"PLpgSQL_row"`
	Variable    *plpgSQL_var      `json:"PLpgSQL_var"`
}

// elsif exists to match the expected JSON format.
type elsif struct {
	ElseIf plpgSQL_if_elsif `json:"PLpgSQL_if_elsif"`
}

// expr exists to match the expected JSON format.
type expr struct {
	Expression plpgSQL_expr `json:"PLpgSQL_expr"`
}

// field exists to match the expected JSON format.
type field struct {
	Name           string `json:"name"`
	VariableNumber int32  `json:"varno"`
}

// function exists to match the expected JSON format.
type function struct {
	Function plpgSQL_block `json:"PLpgSQL_function"`
}

// plpgSQL_block exists to match the expected JSON format.
type plpgSQL_block struct {
	NewVariableNumber int32   `json:"new_varno"`
	OldVariableNumber int32   `json:"old_varno"`
	Datums            []datum `json:"datums"`
	Action            action  `json:"action"`
}

// plpgSQL_expr exists to match the expected JSON format.
type plpgSQL_expr struct {
	Query     string `json:"query"`
	ParseMode int32  `json:"parseMode"`
}

// plpgSQL_if_elsif exists to match the expected JSON format.
type plpgSQL_if_elsif struct {
	Condition  cond        `json:"cond"`
	Then       []statement `json:"stmts"`
	LineNumber int32       `json:"lineno"`
}

// plpgSQL_rec exists to match the expected JSON format.
type plpgSQL_rec struct {
	RefName     string `json:"refname"`
	DatumNumber int32  `json:"dno"`
}

// plpgSQL_recfield exists to match the expected JSON format.
type plpgSQL_recfield struct {
	FieldName          string `json:"fieldname"`
	RecordParentNumber int32  `json:"recparentno"`
}

// plpgSQL_row exists to match the expected JSON format.
type plpgSQL_row struct {
	RefName    string  `json:"refname"`
	Fields     []field `json:"fields"`
	LineNumber int32   `json:"lineno"`
}

// plpgSQL_stmt_assign exists to match the expected JSON format.
type plpgSQL_stmt_assign struct {
	Expression     expr  `json:"expr"`
	VariableNumber int32 `json:"varno"`
	LineNumber     int32 `json:"lineno"`
}

// plpgSQL_stmt_block exists to match the expected JSON format.
type plpgSQL_stmt_block struct {
	Body       []statement `json:"body"`
	Label      string      `json:"label"`
	LineNumber int32       `json:"lineno"`
}

// plpgSQL_stmt_call exists to match the expected JSON format.
type plpgSQL_stmt_call struct {
	LineNumber int32 `json:"lineno"`
	Expression expr  `json:"expr"`
	IsCall     bool  `json:"is_call"`
	Target     datum `json:"target"`
}

// plpgSQL_stmt_case exists to match the expected JSON format.
type plpgSQL_stmt_case struct {
	LineNumber int32 `json:"lineno"`
	Expression expr  `json:"t_expr"`
	// VarNo indicates the ID for the __Case__Variable_N__ variable that holds the evaluated
	// value of the case expression.
	VarNo    int32       `json:"t_varno"`
	WhenList []statement `json:"case_when_list"`
	HasElse  bool        `json:"have_else"`
	Else     []statement `json:"else_stmts"`
}

// plpgSQL_stmt_dynexecute exists to match the expected JSON format.
type plpgSQL_stmt_dynexecute struct {
	LineNumber int32     `json:"lineno"`
	Into       bool      `json:"into"`
	Query      expr      `json:"query"`
	Target     datum     `json:"target"`
	Params     []sqlstmt `json:"params"`
}

// plpgSQL_case_when exists to match the expected JSON format.
type plpgSQL_case_when struct {
	LineNumber int32       `json:"lineno"`
	Expression expr        `json:"expr"`
	Body       []statement `json:"stmts"`
}

// plpgSQL_stmt_execsql exists to match the expected JSON format.
type plpgSQL_stmt_execsql struct {
	SQLStmt    sqlstmt `json:"sqlstmt"`
	LineNumber int32   `json:"lineno"`
	Into       bool    `json:"into"`
	Target     datum   `json:"target"`
}

// plpgSQL_stmt_exit exists to match the expected JSON format.
type plpgSQL_stmt_exit struct {
	Label      string `json:"label"`
	IsExit     bool   `json:"is_exit"`
	Condition  *expr  `json:"cond"`
	LineNumber int32  `json:"lineno"`
}

// plpgSQL_stmt_fori exists to match the expected JSON format.
type plpgSQL_stmt_fori struct {
	Label      string      `json:"label"`
	Var        datum       `json:"var"`
	Lower      *expr       `json:"lower"`
	Upper      *expr       `json:"upper"`
	Step       *expr       `json:"step"`
	Reverse    bool        `json:"reverse"`
	Body       []statement `json:"body"`
	LineNumber int32       `json:"lineno"`
}

// plpgSQL_stmt_fors exists to match the expected JSON format.
type plpgSQL_stmt_fors struct {
	Label      string      `json:"label"`
	Var        datum       `json:"var"`
	Body       []statement `json:"body"`
	Query      *expr       `json:"query"`
	LineNumber int32       `json:"lineno"`
}

// plpgSQL_stmt_if exists to match the expected JSON format.
type plpgSQL_stmt_if struct {
	Condition  cond        `json:"cond"`
	Then       []statement `json:"then_body"`
	ElseIf     []elsif     `json:"elsif_list"`
	Else       []statement `json:"else_body"`
	LineNumber int32       `json:"lineno"`
}

// plpgSQL_stmt_loop exists to match the expected JSON format.
type plpgSQL_stmt_loop struct {
	Body       []statement `json:"body"`
	Label      string      `json:"label"`
	LineNumber int32       `json:"lineno"`
}

// plpgSQL_stmt_perform exists to match the expected JSON format.
type plpgSQL_stmt_perform struct {
	Expression expr  `json:"expr"`
	LineNumber int32 `json:"lineno"`
}

// plpgSQL_stmt_raise exists to match the expected JSON format.
type plpgSQL_stmt_raise struct {
	LineNumber int32                          `json:"lineno"`
	ELogLevel  int32                          `json:"elog_level"`
	Message    string                         `json:"message"`
	Params     []sqlstmt                      `json:"params"`
	Options    []plpgSQL_raise_option_wrapper `json:"options"`
}

// plpgSQL_raise_option_wrapper exists to match the expected JSON format.
type plpgSQL_raise_option_wrapper struct {
	Option plpgSQL_raise_option `json:"PLpgSQL_raise_option"`
}

// plpgSQL_raise_option exists to match the expected JSON format.
type plpgSQL_raise_option struct {
	OptionType int32   `json:"opt_type"`
	Expression sqlstmt `json:"expr"`
}

// plpgSQL_stmt_return exists to match the expected JSON format.
type plpgSQL_stmt_return struct {
	Expression expr  `json:"expr"`
	LineNumber int32 `json:"lineno"`
}

// plpgSQL_stmt_return_query exists to match the expected JSON format.
type plpgSQL_stmt_return_query struct {
	Query      expr  `json:"query"`
	LineNumber int32 `json:"lineno"`
}

// plpgSQL_stmt_while exists to match the expected JSON format.
type plpgSQL_stmt_while struct {
	Condition  cond        `json:"cond"`
	Body       []statement `json:"body"`
	Label      string      `json:"label"`
	LineNumber int32       `json:"lineno"`
}

// plpgSQL_type exists to match the expected JSON format.
type plpgSQL_type struct {
	Name string `json:"typname"`
}

// plpgSQL_var exists to match the expected JSON format.
type plpgSQL_var struct {
	RefName    string      `json:"refname"`
	Type       datatype    `json:"datatype"`
	LineNumber int32       `json:"lineno"`
	Default    default_val `json:"default_val"`
}

// sqlstmt exists to match the expected JSON format.
type sqlstmt struct {
	Expr plpgSQL_expr `json:"PLpgSQL_expr"`
}

// statement exists to match the expected JSON format. Unlike other structs, this is used like a union rather than
// having a singular expected implementation.
type statement struct {
	Assignment  *plpgSQL_stmt_assign       `json:"PLpgSQL_stmt_assign"`
	Block       *plpgSQL_stmt_block        `json:"PLpgSQL_stmt_block"`
	Call        *plpgSQL_stmt_call         `json:"PLpgSQL_stmt_call"`
	Case        *plpgSQL_stmt_case         `json:"PLpgSQL_stmt_case"`
	DynExec     *plpgSQL_stmt_dynexecute   `json:"PLpgSQL_stmt_dynexecute"`
	ExecSQL     *plpgSQL_stmt_execsql      `json:"PLpgSQL_stmt_execsql"`
	Exit        *plpgSQL_stmt_exit         `json:"PLpgSQL_stmt_exit"`
	ForILoop    *plpgSQL_stmt_fori         `json:"PLpgSQL_stmt_fori"`
	ForSLoop    *plpgSQL_stmt_fors         `json:"PLpgSQL_stmt_fors"`
	If          *plpgSQL_stmt_if           `json:"PLpgSQL_stmt_if"`
	Loop        *plpgSQL_stmt_loop         `json:"PLpgSQL_stmt_loop"`
	Perform     *plpgSQL_stmt_perform      `json:"PLpgSQL_stmt_perform"`
	Raise       *plpgSQL_stmt_raise        `json:"PLpgSQL_stmt_raise"`
	Return      *plpgSQL_stmt_return       `json:"PLpgSQL_stmt_return"`
	ReturnQuery *plpgSQL_stmt_return_query `json:"PLpgSQL_stmt_return_query"`
	When        *plpgSQL_case_when         `json:"PLpgSQL_case_when"`
	While       *plpgSQL_stmt_while        `json:"PLpgSQL_stmt_while"`
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_assign) Convert() (Assignment, error) {
	query := stmt.Expression.Expression.Query
	varName := ""
	if equalsIdx := strings.Index(query, ":="); equalsIdx > 0 {
		varName = strings.TrimSpace(query[:equalsIdx])
		query = strings.TrimSpace(query[equalsIdx+2:])
	} else if equalsIdx = strings.Index(query, "="); equalsIdx > 0 {
		varName = strings.TrimSpace(query[:equalsIdx])
		query = strings.TrimSpace(query[equalsIdx+1:])
	} else {
		return Assignment{}, errors.New("PL/pgSQL assignment cannot find `:=` sign")
	}
	return Assignment{
		VariableName:  varName,
		Expression:    query,
		VariableIndex: stmt.VariableNumber,
	}, nil
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_call) Convert() (ExecuteSQL, error) {
	var target string
	if !stmt.IsCall {
		if stmt.Target.Row != nil {
			names := make([]string, len(stmt.Target.Row.Fields))
			for i, rowField := range stmt.Target.Row.Fields {
				names[i] = rowField.Name
			}
			target = strings.Join(names, ",")
		} else if stmt.Target.Variable != nil {
			target = stmt.Target.Variable.RefName
		} else {
			return ExecuteSQL{}, errors.Errorf("unhandled datum type: %T", stmt.Target)
		}
	}
	return ExecuteSQL{
		Statement: stmt.Expression.Expression.Query,
		Target:    target,
	}, nil
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_case) Convert() (block Block, err error) {
	// If the CASE statement has a main expression, start by assigning it to a variable so
	// we can evaluate it once and only once.
	if stmt.Expression.Expression.Query != "" {
		// TODO: pg_query_go creates the definitions for these variables, and
		//       ideally users shouldn't be able to reference them. We could
		//       update all the references to them (i.e. declaration, assignment,
		//       and WHEN block exprs) to change the name to include a \0 char to
		//       prevent users from referencing them or colliding with them.
		block.Body = append(block.Body, Assignment{
			VariableName: fmt.Sprintf("__Case__Variable_%d__", stmt.VarNo),
			Expression:   stmt.Expression.Expression.Query,
		})
	}

	// Record indexes of all the GOTO ops that jump to the very end of the case block so we
	// can update them later and plug in the correct offsets after we know the final size.
	var gotoEndOpsIndexes []int

	// Add operations for each WHEN statement...
	for _, stmt := range stmt.WhenList {
		when := stmt.When
		if when == nil {
			return Block{}, fmt.Errorf("case statement WHEN clause is nil")
		}

		// TODO: The generated expressions from pg_query_go uses double quotes
		//       around the variable name, which is valid for Postgres, but
		//       our engine doesn't currently resolve double-quoted strings to
		//       variables, so for now, we just extract the double quotes.
		expressionString := when.Expression.Expression.Query
		expressionString = strings.ReplaceAll(expressionString, `"`, "")

		convertedWhenBodyStatements, err := jsonConvertStatements(when.Body)
		if err != nil {
			return Block{}, err
		}

		block.Body = append(block.Body,
			If{
				Condition:  expressionString,
				GotoOffset: 2,
			},
			Goto{
				// This GOTO jumps to the next WHEN block, so step over all the statements
				// from this WHEN block, plus 1 for the GOTO op we add at the end of each
				// block, and plus 1 more to move to the next statement.
				Offset: int32(len(convertedWhenBodyStatements) + 1 + 1),
			})
		block.Body = append(block.Body, convertedWhenBodyStatements...)

		// Add a GOTO op to jump to the end of the entire CASE block, and record its position
		// in the statement block so we can update it later.
		block.Body = append(block.Body, Goto{})
		gotoEndOpsIndexes = append(gotoEndOpsIndexes, len(block.Body)-1)
	}

	if stmt.HasElse {
		convertElseBodyStatements, err := jsonConvertStatements(stmt.Else)
		if err != nil {
			return Block{}, err
		}
		block.Body = append(block.Body, convertElseBodyStatements...)
		// TODO: If no cases match and there is no ELSE block, then add a RAISE statement
		//       to return an error.
		//} else {
		// Sample PostgreSQL error response:
		//	     ERROR:  case not found
		//	     HINT:  CASE statement is missing ELSE part.
		//	     CONTEXT:  PL/pgSQL function interpreted_case(integer) line 5 at CASE
	}

	// Update all the GOTO ops that jump to the very end of the case block.
	for _, gotoEndOpIndex := range gotoEndOpsIndexes {
		// Sanity check that we are looking at a GOTO statement
		if _, ok := block.Body[gotoEndOpIndex].(Goto); !ok {
			return Block{}, fmt.Errorf("expected Goto statement, got %T", block.Body[gotoEndOpIndex])
		}

		block.Body[gotoEndOpIndex] = Goto{
			Offset: int32(len(block.Body) - gotoEndOpIndex),
		}
	}

	return block, nil
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_dynexecute) Convert() (DynamicExecute, error) {
	var params []string
	for _, param := range stmt.Params {
		params = append(params, param.Expr.Query)
	}
	var target string
	if stmt.Into {
		switch {
		case stmt.Target.Row != nil:
			names := make([]string, len(stmt.Target.Row.Fields))
			for i, rowField := range stmt.Target.Row.Fields {
				names[i] = rowField.Name
			}
			target = strings.Join(names, ",")
		case stmt.Target.Variable != nil:
			target = stmt.Target.Variable.RefName
		default:
			return DynamicExecute{}, errors.Errorf("unhandled datum type: %T", stmt.Target)
		}
	}
	query := strings.TrimSuffix(strings.TrimPrefix(stmt.Query.Expression.Query, "'"), "'")
	return DynamicExecute{
		Query:  query,
		Params: params,
		Target: target,
	}, nil
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_execsql) Convert() (ExecuteSQL, error) {
	var target string
	if stmt.Into {
		if stmt.Target.Row != nil {
			names := make([]string, len(stmt.Target.Row.Fields))
			for i, rowField := range stmt.Target.Row.Fields {
				names[i] = rowField.Name
			}
			target = strings.Join(names, ",")
		} else if stmt.Target.Variable != nil {
			target = stmt.Target.Variable.RefName
		} else {
			return ExecuteSQL{}, errors.Errorf("unhandled datum type: %T", stmt.Target)
		}
	}
	return ExecuteSQL{
		Statement: stmt.SQLStmt.Expr.Query,
		Target:    target,
	}, nil
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_exit) Convert() Statement {
	offset := int32(-1)
	if stmt.IsExit {
		offset = 1
	}
	var gotoStmt Goto
	if len(stmt.Label) > 0 {
		gotoStmt = Goto{
			Offset: offset,
			Label:  stmt.Label,
		}
	} else {
		gotoStmt = Goto{
			Offset:         offset,
			NearestScopeOp: true,
		}
	}
	if stmt.Condition == nil {
		return gotoStmt
	} else {
		return Block{
			Body: []Statement{
				If{
					Condition:  stmt.Condition.Expression.Query,
					GotoOffset: 2,
				},
				Goto{Offset: 2},
				gotoStmt,
			},
		}
	}
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_fori) Convert() (block Block, err error) {
	block.Label = stmt.Label
	block.IsLoop = true

	if stmt.Var.Variable == nil {
		return Block{}, errors.New("for loop variable cannot be nil")
	}
	varName := stmt.Var.Variable.RefName

	// Extract bound and step expressions
	lowerExpr := "1"
	if stmt.Lower != nil {
		lowerExpr = stmt.Lower.Expression.Query
	}
	upperExpr := "1"
	if stmt.Upper != nil {
		upperExpr = stmt.Upper.Expression.Query
	}
	stepExpr := "1"
	if stmt.Step != nil {
		stepExpr = stmt.Step.Expression.Query
	}

	// Determine init value, loop condition, and increment expression based on direction.
	// In the JSON, Lower is always the starting value and Upper is the ending bound.
	var condition, incrExpr string
	if stmt.Reverse {
		condition = fmt.Sprintf("%s >= (%s)", varName, upperExpr)
		incrExpr = fmt.Sprintf("%s - (%s)", varName, stepExpr)
	} else {
		condition = fmt.Sprintf("%s <= (%s)", varName, upperExpr)
		incrExpr = fmt.Sprintf("%s + (%s)", varName, stepExpr)
	}

	// Convert the loop body.
	convertedBody, err := jsonConvertStatements(stmt.Body)
	if err != nil {
		return Block{}, err
	}
	bodySize := OperationSizeForStatements(convertedBody)

	// Build the loop body:
	//   [0]           InitAssign: varName := lower
	//   [1]           If(condition, GotoOffset:2) → jumps to [3] (first body stmt) when true
	//   [2]           ExitGoto → offset=3+bodySize → jumps to ScopeEnd
	//   [3..3+N-1]    body statements (N = bodySize)
	//   [3+N]         IncrAssign: varName := varName +/- step
	//   [3+N+1]       BackGoto → offset=-(3+bodySize) → jumps back to If at [1]
	//
	// Because no variables are declared in this block (the loop variable is already
	// declared by the caller's DECLARE section), ScopeBegin is at M and the
	// InitAssign is at M+1, so all offsets are consistent.
	block.Body = []Statement{
		Assignment{
			VariableName: varName,
			Expression:   lowerExpr,
		},
		If{
			Condition:  condition,
			GotoOffset: 2,
		},
		Goto{
			Offset: 3 + bodySize,
		},
	}
	block.Body = append(block.Body, convertedBody...)
	block.Body = append(block.Body,
		Assignment{
			VariableName: varName,
			Expression:   incrExpr,
		},
		Goto{
			Offset: -(3 + bodySize),
		},
	)
	return block, nil
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_fors) Convert() (block Block, err error) {
	block.Label = stmt.Label
	block.IsLoop = true

	if stmt.Query == nil {
		return Block{}, errors.New("FOR..IN..SELECT loop must have a query")
	}

	var varName string
	switch {
	case stmt.Var.Record != nil:
		varName = stmt.Var.Record.RefName
	case stmt.Var.Variable != nil:
		varName = stmt.Var.Variable.RefName
	case stmt.Var.Row != nil:
		varName = stmt.Var.Row.RefName
	default:
		return Block{}, errors.New("FOR..IN..SELECT loop variable must be a record, row, or variable")
	}

	// Use the line number to keep cursor names unique across multiple ForS loops
	// that might use the same variable name.
	cursorName := fmt.Sprintf("__cursor_%s_%d__", varName, stmt.LineNumber)
	query := stmt.Query.Expression.Query

	convertedBody, err := jsonConvertStatements(stmt.Body)
	if err != nil {
		return Block{}, err
	}
	bodySize := OperationSizeForStatements(convertedBody)

	// Layout inside the block (ScopeBegin/ScopeEnd are added by Block.AppendOperations):
	//   [0] ForQueryInit  – execute query, store rows in cursor
	//   [1] ForQueryNext  – fetch next row into varName, or jump forward by (bodySize+2) to ScopeEnd
	//   [2..2+bodySize-1] body statements
	//   [2+bodySize]      Goto back to ForQueryNext: offset = -(1 + bodySize)
	block.Body = []Statement{
		ForQueryInit{CursorName: cursorName, Query: query},
		ForQueryNext{CursorName: cursorName, RecordVar: varName, GotoOffset: bodySize + 2},
	}
	block.Body = append(block.Body, convertedBody...)
	block.Body = append(block.Body, Goto{Offset: -(1 + bodySize)})
	return block, nil
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_if) Convert() (Block, error) {
	// We store all GOTOs that will need to go to the end of the block. Since we can't know that ahead of time, we store
	// their indexes and set them at the end of the function.
	type gotoEndIndex struct {
		BodyIndex int
		GotoIndex int32
	}
	var gotoEndIndexes []gotoEndIndex
	returnBlock := Block{
		Body: []Statement{
			If{
				Condition:  stmt.Condition.Expression.Query,
				GotoOffset: 2, // The operation following the conditional skips the THEN statements, so we're skipping that
			},
		},
	}
	// We'll parse our THEN statements, but we won't add them to the block just yet as we need their operation sizes
	thenStmts, err := jsonConvertStatements(stmt.Then)
	if err != nil {
		return Block{}, err
	}
	// When the condition is false, we want to skip our THEN block, so we do that (plus the GOTO which finishes the THEN block)
	returnBlock.Body = append(returnBlock.Body, Goto{Offset: OperationSizeForStatements(thenStmts) + 2})
	// Then we'll append our THEN block
	returnBlock.Body = append(returnBlock.Body, thenStmts...)
	// Then we want to append the GOTO that finishes the THEN block, but we don't know the end just yet, so we'll save
	// its index and fill it in later
	gotoEndIndexes = append(gotoEndIndexes, gotoEndIndex{
		BodyIndex: len(returnBlock.Body),
		GotoIndex: OperationSizeForStatements(returnBlock.Body),
	})
	returnBlock.Body = append(returnBlock.Body, Goto{})
	// We repeat the same process for each ELSIF statement (refer to the comments above)
	for _, elseIf := range stmt.ElseIf {
		returnBlock.Body = append(returnBlock.Body, If{
			Condition:  elseIf.ElseIf.Condition.Expression.Query,
			GotoOffset: 2, // Same rules as skipping our THEN statement above
		})
		elseIfStmts, err := jsonConvertStatements(elseIf.ElseIf.Then)
		if err != nil {
			return Block{}, err
		}
		returnBlock.Body = append(returnBlock.Body, Goto{Offset: OperationSizeForStatements(elseIfStmts) + 2})
		returnBlock.Body = append(returnBlock.Body, elseIfStmts...)
		gotoEndIndexes = append(gotoEndIndexes, gotoEndIndex{
			BodyIndex: len(returnBlock.Body),
			GotoIndex: OperationSizeForStatements(returnBlock.Body),
		})
		returnBlock.Body = append(returnBlock.Body, Goto{})
	}
	// Finally we handle our ELSE statements. We don't have a condition to check, so we don't have to append any
	// additional GOTOs.
	elseStmts, err := jsonConvertStatements(stmt.Else)
	if err != nil {
		return Block{}, err
	}
	returnBlock.Body = append(returnBlock.Body, elseStmts...)
	// Now we'll set all of our GOTOs so that they skip to the end of the block.
	// We have to take their index position into account, since we want to skip to the end from their relative position.
	for _, idx := range gotoEndIndexes {
		returnBlock.Body[idx.BodyIndex] = Goto{Offset: OperationSizeForStatements(returnBlock.Body) - idx.GotoIndex}
	}
	return returnBlock, nil
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_loop) Convert() (block Block, err error) {
	// Set the block's label if one was provided
	block.Label = stmt.Label
	block.IsLoop = true
	// Convert the body of the loop first so we can determine the GOTO offset
	block.Body, err = jsonConvertStatements(stmt.Body)
	if err != nil {
		return Block{}, err
	}
	// The loop returns to the beginning of the loop, skipping the body
	block.Body = append(block.Body, Goto{Offset: -OperationSizeForStatements(block.Body)})
	return block, nil
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_perform) Convert() Perform {
	return Perform{
		Statement: stmt.Expression.Expression.Query,
	}
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_raise) Convert() Raise {
	var params []string
	for _, param := range stmt.Params {
		params = append(params, param.Expr.Query)
	}

	options := make(map[string]string)
	for _, option := range stmt.Options {
		options[strconv.Itoa(int(option.Option.OptionType))] = option.Option.Expression.Expr.Query
	}

	return Raise{
		Level:   NoticeLevel(uint8(stmt.ELogLevel)).String(),
		Message: stmt.Message,
		Params:  params,
		Options: options,
	}
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_return) Convert() Return {
	return Return{
		Expression: stmt.Expression.Expression.Query,
	}
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_return_query) Convert() ReturnQuery {
	return ReturnQuery{
		Query: stmt.Query.Expression.Query,
	}
}

// Convert converts the JSON statement into its output form.
func (stmt *plpgSQL_stmt_while) Convert() (block Block, err error) {
	// Convert the body of the loop first so we can determine the GOTO offsets
	convertedLoopBodyStmts, err := jsonConvertStatements(stmt.Body)
	if err != nil {
		return Block{}, err
	}

	block = Block{
		Body: []Statement{
			If{
				Condition: stmt.Condition.Expression.Query,
				// Jump forward two statements, so we skip over the GOTO below that exits the WHILE loop.
				GotoOffset: 2,
			},
			Goto{
				// Jump forward 1 statement to get to the loop body, then jump over the loop body and the
				// GOTO statement that jumps to the start of the WHILE loop.
				Offset: 1 + OperationSizeForStatements(convertedLoopBodyStmts) + 1,
			},
		},
		Label:  stmt.Label,
		IsLoop: true,
	}

	// Add the converted body of the WHILE loop, and a GOTO statement that jumps backwards past the current
	// GOTO statement, and past all the body statements, and past the GOTO statement at the start of the loop.
	block.Body = append(block.Body, convertedLoopBodyStmts...)
	block.Body = append(block.Body, Goto{Offset: -1 * (OperationSizeForStatements(convertedLoopBodyStmts) + 2)})
	return block, nil
}