/* WIP Under Really Heavy Construction */
package qgen

import (
	"errors"
	"log"
	"strconv"
	"strings"
)

func init() {
	Registry = append(Registry,
		&MssqlAdapter{Name: "mssql", Buffer: make(map[string]DBStmt)},
	)
}

type MssqlAdapter struct {
	Name        string // ? - Do we really need this? Can't we hard-code this?
	Buffer      map[string]DBStmt
	BufferOrder []string // Map iteration order is random, so we need this to track the order, so we don't get huge diffs every commit
	keys        map[string]string
}

// GetName gives you the name of the database adapter. In this case, it's Mssql
func (adapter *MssqlAdapter) GetName() string {
	return adapter.Name
}

func (adapter *MssqlAdapter) GetStmt(name string) DBStmt {
	return adapter.Buffer[name]
}

func (adapter *MssqlAdapter) GetStmts() map[string]DBStmt {
	return adapter.Buffer
}

// TODO: Convert any remaining stringy types to nvarchar
// We may need to change the CreateTable API to better suit Mssql and the other database drivers which are coming up
func (adapter *MssqlAdapter) CreateTable(name string, table string, charset string, collation string, columns []DBTableColumn, keys []DBTableKey) (string, error) {
	if name == "" {
		return "", errors.New("You need a name for this statement")
	}
	if table == "" {
		return "", errors.New("You need a name for this table")
	}
	if len(columns) == 0 {
		return "", errors.New("You can't have a table with no columns")
	}

	var querystr = "CREATE TABLE [" + table + "] ("
	for _, column := range columns {
		var max bool
		var createdAt bool
		switch column.Type {
		case "createdAt":
			column.Type = "datetime"
			createdAt = true
		case "varchar":
			column.Type = "nvarchar"
		case "text":
			column.Type = "nvarchar"
			max = true
		case "boolean":
			column.Type = "bit"
		}

		var size string
		if column.Size > 0 {
			size = " (" + strconv.Itoa(column.Size) + ")"
		}
		if max {
			size = " (MAX)"
		}

		var end string
		if column.Default != "" {
			end = " DEFAULT "
			if createdAt {
				end += "GETUTCDATE()" // TODO: Use GETUTCDATE() in updates instead of the neutral format
			} else if adapter.stringyType(column.Type) && column.Default != "''" {
				end += "'" + column.Default + "'"
			} else {
				end += column.Default
			}
		}

		if !column.Null {
			end += " not null"
		}

		// ! Not exactly the meaning of auto increment...
		if column.AutoIncrement {
			end += " IDENTITY"
		}

		querystr += "\n\t[" + column.Name + "] " + column.Type + size + end + ","
	}

	if len(keys) > 0 {
		for _, key := range keys {
			querystr += "\n\t" + key.Type
			if key.Type != "unique" {
				querystr += " key"
			}
			querystr += "("
			for _, column := range strings.Split(key.Columns, ",") {
				querystr += "[" + column + "],"
			}
			querystr = querystr[0:len(querystr)-1] + "),"
		}
	}

	querystr = querystr[0:len(querystr)-1] + "\n);"
	adapter.pushStatement(name, "create-table", querystr)
	return querystr, nil
}

func (adapter *MssqlAdapter) SimpleInsert(name string, table string, columns string, fields string) (string, error) {
	if name == "" {
		return "", errors.New("You need a name for this statement")
	}
	if table == "" {
		return "", errors.New("You need a name for this table")
	}
	if len(columns) == 0 {
		return "", errors.New("No columns found for SimpleInsert")
	}
	if len(fields) == 0 {
		return "", errors.New("No input data found for SimpleInsert")
	}

	var querystr = "INSERT INTO [" + table + "] ("

	// Escape the column names, just in case we've used a reserved keyword
	for _, column := range processColumns(columns) {
		if column.Type == "function" {
			querystr += column.Left + ","
		} else {
			querystr += "[" + column.Left + "],"
		}
	}
	// Remove the trailing comma
	querystr = querystr[0 : len(querystr)-1]

	querystr += ") VALUES ("
	for _, field := range processFields(fields) {
		field.Name = strings.Replace(field.Name, "UTC_TIMESTAMP()", "GETUTCDATE()", -1)
		//log.Print("field.Name ", field.Name)
		nameLen := len(field.Name)
		if field.Name[0] == '"' && field.Name[nameLen-1] == '"' && nameLen >= 3 {
			field.Name = "'" + field.Name[1:nameLen-1] + "'"
		}
		if field.Name[0] == '\'' && field.Name[nameLen-1] == '\'' && nameLen >= 3 {
			field.Name = "'" + strings.Replace(field.Name[1:nameLen-1], "'", "''", -1) + "'"
		}
		querystr += field.Name + ","
	}
	querystr = querystr[0 : len(querystr)-1]

	adapter.pushStatement(name, "insert", querystr+")")
	return querystr + ")", nil
}

// ! DEPRECATED
func (adapter *MssqlAdapter) SimpleReplace(name string, table string, columns string, fields string) (string, error) {
	log.Print("In SimpleReplace")
	key, ok := adapter.keys[table]
	if !ok {
		return "", errors.New("Unable to elide key from table '" + table + "', please use SimpleUpsert (coming soon!) instead")
	}
	log.Print("After the key check")

	// Escape the column names, just in case we've used a reserved keyword
	var keyPosition int
	for _, column := range processColumns(columns) {
		if column.Left == key {
			continue
		}
		keyPosition++
	}

	var keyValue string
	for fieldID, field := range processFields(fields) {
		field.Name = strings.Replace(field.Name, "UTC_TIMESTAMP()", "GETUTCDATE()", -1)
		nameLen := len(field.Name)
		if field.Name[0] == '"' && field.Name[nameLen-1] == '"' && nameLen >= 3 {
			field.Name = "'" + field.Name[1:nameLen-1] + "'"
		}
		if field.Name[0] == '\'' && field.Name[nameLen-1] == '\'' && nameLen >= 3 {
			field.Name = "'" + strings.Replace(field.Name[1:nameLen-1], "'", "''", -1) + "'"
		}
		if keyPosition == fieldID {
			keyValue = field.Name
			continue
		}
	}
	return adapter.SimpleUpsert(name, table, columns, fields, "key = "+keyValue)
}

func (adapter *MssqlAdapter) SimpleUpsert(name string, table string, columns string, fields string, where string) (string, error) {
	if name == "" {
		return "", errors.New("You need a name for this statement")
	}
	if table == "" {
		return "", errors.New("You need a name for this table")
	}
	if len(columns) == 0 {
		return "", errors.New("No columns found for SimpleInsert")
	}
	if len(fields) == 0 {
		return "", errors.New("No input data found for SimpleInsert")
	}

	var fieldCount int
	var fieldOutput string
	var querystr = "MERGE [" + table + "] WITH(HOLDLOCK) as t1 USING (VALUES("

	var parsedFields = processFields(fields)
	for _, field := range parsedFields {
		fieldCount++
		field.Name = strings.Replace(field.Name, "UTC_TIMESTAMP()", "GETUTCDATE()", -1)
		//log.Print("field.Name ", field.Name)
		nameLen := len(field.Name)
		if field.Name[0] == '"' && field.Name[nameLen-1] == '"' && nameLen >= 3 {
			field.Name = "'" + field.Name[1:nameLen-1] + "'"
		}
		if field.Name[0] == '\'' && field.Name[nameLen-1] == '\'' && nameLen >= 3 {
			field.Name = "'" + strings.Replace(field.Name[1:nameLen-1], "'", "''", -1) + "'"
		}
		fieldOutput += field.Name + ","
	}
	fieldOutput = fieldOutput[0 : len(fieldOutput)-1]
	querystr += fieldOutput + ")) AS updates ("

	// nolint The linter wants this to be less readable
	for fieldID, _ := range parsedFields {
		querystr += "f" + strconv.Itoa(fieldID) + ","
	}
	querystr = querystr[0 : len(querystr)-1]
	querystr += ") ON "

	//querystr += "t1.[" + key + "] = "
	// Add support for BETWEEN x.x
	for _, loc := range processWhere(where) {
		for _, token := range loc.Expr {
			switch token.Type {
			case "substitute":
				querystr += " ?"
			case "function", "operator", "number":
				// TODO: Split the function case off to speed things up
				if strings.ToUpper(token.Contents) == "UTC_TIMESTAMP()" {
					token.Contents = "GETUTCDATE()"
				}
				querystr += " " + token.Contents
			case "column":
				querystr += " [" + token.Contents + "]"
			case "string":
				querystr += " '" + token.Contents + "'"
			default:
				panic("This token doesn't exist o_o")
			}
		}
	}

	var matched = " WHEN MATCHED THEN UPDATE SET "
	var notMatched = "WHEN NOT MATCHED THEN INSERT("
	var fieldList string

	// Escape the column names, just in case we've used a reserved keyword
	for columnID, column := range processColumns(columns) {
		fieldList += "f" + strconv.Itoa(columnID) + ","
		if column.Type == "function" {
			matched += column.Left + " = f" + strconv.Itoa(columnID) + ","
			notMatched += column.Left + ","
		} else {
			matched += "[" + column.Left + "] = f" + strconv.Itoa(columnID) + ","
			notMatched += "[" + column.Left + "],"
		}
	}

	matched = matched[0 : len(matched)-1]
	notMatched = notMatched[0 : len(notMatched)-1]
	fieldList = fieldList[0 : len(fieldList)-1]

	notMatched += ") VALUES (" + fieldList + ");"
	querystr += matched + " " + notMatched

	// TODO: Run this on debug mode?
	if name[0] == '_' {
		log.Print(name+" query: ", querystr)
	}
	adapter.pushStatement(name, "upsert", querystr)
	return querystr, nil
}

func (adapter *MssqlAdapter) SimpleUpdate(name string, table string, set string, where string) (string, error) {
	if name == "" {
		return "", errors.New("You need a name for this statement")
	}
	if table == "" {
		return "", errors.New("You need a name for this table")
	}
	if set == "" {
		return "", errors.New("You need to set data in this update statement")
	}

	var querystr = "UPDATE [" + table + "] SET "
	for _, item := range processSet(set) {
		querystr += "[" + item.Column + "] ="
		for _, token := range item.Expr {
			switch token.Type {
			case "substitute":
				querystr += " ?"
			case "function", "operator", "number":
				// TODO: Split the function case off to speed things up
				if strings.ToUpper(token.Contents) == "UTC_TIMESTAMP()" {
					token.Contents = "GETUTCDATE()"
				}
				querystr += " " + token.Contents
			case "column":
				querystr += " [" + token.Contents + "]"
			case "string":
				querystr += " '" + token.Contents + "'"
			default:
				panic("This token doesn't exist o_o")
			}
		}
		querystr += ","
	}
	// Remove the trailing comma
	querystr = querystr[0 : len(querystr)-1]

	// Add support for BETWEEN x.x
	if len(where) != 0 {
		querystr += " WHERE"
		for _, loc := range processWhere(where) {
			for _, token := range loc.Expr {
				switch token.Type {
				case "function", "operator", "number", "substitute":
					// TODO: Split the function case off to speed things up
					if strings.ToUpper(token.Contents) == "UTC_TIMESTAMP()" {
						token.Contents = "GETUTCDATE()"
					}
					querystr += " " + token.Contents
				case "column":
					querystr += " [" + token.Contents + "]"
				case "string":
					querystr += " '" + token.Contents + "'"
				default:
					panic("This token doesn't exist o_o")
				}
			}
			querystr += " AND"
		}
		querystr = querystr[0 : len(querystr)-4]
	}

	adapter.pushStatement(name, "update", querystr)
	return querystr, nil
}

func (adapter *MssqlAdapter) SimpleDelete(name string, table string, where string) (string, error) {
	if name == "" {
		return "", errors.New("You need a name for this statement")
	}
	if table == "" {
		return "", errors.New("You need a name for this table")
	}
	if where == "" {
		return "", errors.New("You need to specify what data you want to delete")
	}

	var querystr = "DELETE FROM [" + table + "] WHERE"

	// Add support for BETWEEN x.x
	for _, loc := range processWhere(where) {
		for _, token := range loc.Expr {
			switch token.Type {
			case "substitute":
				querystr += " ?"
			case "function", "operator", "number":
				// TODO: Split the function case off to speed things up
				if strings.ToUpper(token.Contents) == "UTC_TIMESTAMP()" {
					token.Contents = "GETUTCDATE()"
				}
				querystr += " " + token.Contents
			case "column":
				querystr += " [" + token.Contents + "]"
			case "string":
				querystr += " '" + token.Contents + "'"
			default:
				panic("This token doesn't exist o_o")
			}
		}
		querystr += " AND"
	}

	querystr = strings.TrimSpace(querystr[0 : len(querystr)-4])
	adapter.pushStatement(name, "delete", querystr)
	return querystr, nil
}

// We don't want to accidentally wipe tables, so we'll have a separate method for purging tables instead
func (adapter *MssqlAdapter) Purge(name string, table string) (string, error) {
	if name == "" {
		return "", errors.New("You need a name for this statement")
	}
	if table == "" {
		return "", errors.New("You need a name for this table")
	}
	adapter.pushStatement(name, "purge", "DELETE FROM ["+table+"]")
	return "DELETE FROM [" + table + "]", nil
}

func (adapter *MssqlAdapter) SimpleSelect(name string, table string, columns string, where string, orderby string, limit string) (string, error) {
	if name == "" {
		return "", errors.New("You need a name for this statement")
	}
	if table == "" {
		return "", errors.New("You need a name for this table")
	}
	if len(columns) == 0 {
		return "", errors.New("No columns found for SimpleSelect")
	}
	// TODO: Add this to the MySQL adapter in order to make this problem more discoverable?
	if len(orderby) == 0 && limit != "" {
		return "", errors.New("Orderby needs to be set to use limit on Mssql")
	}

	var substituteCount = 0
	var querystr = ""

	// Escape the column names, just in case we've used a reserved keyword
	var colslice = strings.Split(strings.TrimSpace(columns), ",")
	for _, column := range colslice {
		querystr += "[" + strings.TrimSpace(column) + "],"
	}
	// Remove the trailing comma
	querystr = querystr[0 : len(querystr)-1]

	querystr += " FROM [" + table + "]"

	// Add support for BETWEEN x.x
	if len(where) != 0 {
		querystr += " WHERE"
		for _, loc := range processWhere(where) {
			for _, token := range loc.Expr {
				switch token.Type {
				case "substitute":
					substituteCount++
					querystr += " ?" + strconv.Itoa(substituteCount)
				case "function", "operator", "number":
					// TODO: Split the function case off to speed things up
					// MSSQL seems to convert the formats? so we'll compare it with a regular date. Do this with the other methods too?
					if strings.ToUpper(token.Contents) == "UTC_TIMESTAMP()" {
						token.Contents = "GETDATE()"
					}
					querystr += " " + token.Contents
				case "column":
					querystr += " [" + token.Contents + "]"
				case "string":
					querystr += " '" + token.Contents + "'"
				default:
					panic("This token doesn't exist o_o")
				}
			}
			querystr += " AND"
		}
		querystr = querystr[0 : len(querystr)-4]
	}

	// TODO: MSSQL requires ORDER BY for LIMIT
	if len(orderby) != 0 {
		querystr += " ORDER BY "
		for _, column := range processOrderby(orderby) {
			// TODO: We might want to escape this column
			querystr += column.Column + " " + strings.ToUpper(column.Order) + ","
		}
		querystr = querystr[0 : len(querystr)-1]
	}

	if limit != "" {
		limiter := processLimit(limit)
		log.Printf("limiter: %+v\n", limiter)
		if limiter.Offset != "" {
			if limiter.Offset == "?" {
				substituteCount++
				querystr += " OFFSET ?" + strconv.Itoa(substituteCount) + " ROWS"
			} else {
				querystr += " OFFSET " + limiter.Offset + " ROWS"
			}
		}

		// ! Does this work without an offset?
		if limiter.MaxCount != "" {
			if limiter.MaxCount == "?" {
				substituteCount++
				limiter.MaxCount = "?" + strconv.Itoa(substituteCount)
			}
			querystr += " FETCH NEXT " + limiter.MaxCount + " ROWS ONLY "
		}
	}

	querystr = strings.TrimSpace("SELECT " + querystr)
	// TODO: Run this on debug mode?
	if name[0] == '_' && limit == "" {
		log.Print(name+" query: ", querystr)
	}
	adapter.pushStatement(name, "select", querystr)
	return querystr, nil
}

func (adapter *MssqlAdapter) SimpleLeftJoin(name string, table1 string, table2 string, columns string, joiners string, where string, orderby string, limit string) (string, error) {
	if name == "" {
		return "", errors.New("You need a name for this statement")
	}
	if table1 == "" {
		return "", errors.New("You need a name for the left table")
	}
	if table2 == "" {
		return "", errors.New("You need a name for the right table")
	}
	if len(columns) == 0 {
		return "", errors.New("No columns found for SimpleLeftJoin")
	}
	if len(joiners) == 0 {
		return "", errors.New("No joiners found for SimpleLeftJoin")
	}
	// TODO: Add this to the MySQL adapter in order to make this problem more discoverable?
	if len(orderby) == 0 && limit != "" {
		return "", errors.New("Orderby needs to be set to use limit on Mssql")
	}
	var substituteCount = 0
	var querystr = ""

	for _, column := range processColumns(columns) {
		var source, alias string

		// Escape the column names, just in case we've used a reserved keyword
		if column.Table != "" {
			source = "[" + column.Table + "].[" + column.Left + "]"
		} else if column.Type == "function" {
			source = column.Left
		} else {
			source = "[" + column.Left + "]"
		}

		if column.Alias != "" {
			alias = " AS '" + column.Alias + "'"
		}
		querystr += source + alias + ","
	}
	// Remove the trailing comma
	querystr = querystr[0 : len(querystr)-1]

	querystr += " FROM [" + table1 + "] LEFT JOIN [" + table2 + "] ON "
	for _, joiner := range processJoiner(joiners) {
		querystr += "[" + joiner.LeftTable + "].[" + joiner.LeftColumn + "] " + joiner.Operator + " [" + joiner.RightTable + "].[" + joiner.RightColumn + "] AND "
	}
	// Remove the trailing AND
	querystr = querystr[0 : len(querystr)-4]

	// Add support for BETWEEN x.x
	if len(where) != 0 {
		querystr += " WHERE"
		for _, loc := range processWhere(where) {
			for _, token := range loc.Expr {
				switch token.Type {
				case "substitute":
					substituteCount++
					querystr += " ?" + strconv.Itoa(substituteCount)
				case "function", "operator", "number":
					// TODO: Split the function case off to speed things up
					if strings.ToUpper(token.Contents) == "UTC_TIMESTAMP()" {
						token.Contents = "GETUTCDATE()"
					}
					querystr += " " + token.Contents
				case "column":
					halves := strings.Split(token.Contents, ".")
					if len(halves) == 2 {
						querystr += " [" + halves[0] + "].[" + halves[1] + "]"
					} else {
						querystr += " [" + token.Contents + "]"
					}
				case "string":
					querystr += " '" + token.Contents + "'"
				default:
					panic("This token doesn't exist o_o")
				}
			}
			querystr += " AND"
		}
		querystr = querystr[0 : len(querystr)-4]
	}

	// TODO: MSSQL requires ORDER BY for LIMIT
	if len(orderby) != 0 {
		querystr += " ORDER BY "
		for _, column := range processOrderby(orderby) {
			log.Print("column: ", column)
			// TODO: We might want to escape this column
			querystr += column.Column + " " + strings.ToUpper(column.Order) + ","
		}
		querystr = querystr[0 : len(querystr)-1]
	} else if limit != "" {
		key, ok := adapter.keys[table1]
		if ok {
			querystr += " ORDER BY [" + table1 + "].[" + key + "]"
		}
	}

	if limit != "" {
		limiter := processLimit(limit)
		if limiter.Offset != "" {
			if limiter.Offset == "?" {
				substituteCount++
				querystr += " OFFSET ?" + strconv.Itoa(substituteCount) + " ROWS"
			} else {
				querystr += " OFFSET " + limiter.Offset + " ROWS"
			}
		}

		// ! Does this work without an offset?
		if limiter.MaxCount != "" {
			if limiter.MaxCount == "?" {
				substituteCount++
				limiter.MaxCount = "?" + strconv.Itoa(substituteCount)
			}
			querystr += " FETCH NEXT " + limiter.MaxCount + " ROWS ONLY "
		}
	}

	querystr = strings.TrimSpace("SELECT " + querystr)
	// TODO: Run this on debug mode?
	if name[0] == '_' && limit == "" {
		log.Print(name+" query: ", querystr)
	}
	adapter.pushStatement(name, "select", querystr)
	return querystr, nil
}

func (adapter *MssqlAdapter) SimpleInnerJoin(name string, table1 string, table2 string, columns string, joiners string, where string, orderby string, limit string) (string, error) {
	if name == "" {
		return "", errors.New("You need a name for this statement")
	}
	if table1 == "" {
		return "", errors.New("You need a name for the left table")
	}
	if table2 == "" {
		return "", errors.New("You need a name for the right table")
	}
	if len(columns) == 0 {
		return "", errors.New("No columns found for SimpleInnerJoin")
	}
	if len(joiners) == 0 {
		return "", errors.New("No joiners found for SimpleInnerJoin")
	}
	// TODO: Add this to the MySQL adapter in order to make this problem more discoverable?
	if len(orderby) == 0 && limit != "" {
		return "", errors.New("Orderby needs to be set to use limit on Mssql")
	}

	var substituteCount = 0
	var querystr = ""

	for _, column := range processColumns(columns) {
		var source, alias string

		// Escape the column names, just in case we've used a reserved keyword
		if column.Table != "" {
			source = "[" + column.Table + "].[" + column.Left + "]"
		} else if column.Type == "function" {
			source = column.Left
		} else {
			source = "[" + column.Left + "]"
		}

		if column.Alias != "" {
			alias = " AS '" + column.Alias + "'"
		}
		querystr += source + alias + ","
	}
	// Remove the trailing comma
	querystr = querystr[0 : len(querystr)-1]

	querystr += " FROM [" + table1 + "] INNER JOIN [" + table2 + "] ON "
	for _, joiner := range processJoiner(joiners) {
		querystr += "[" + joiner.LeftTable + "].[" + joiner.LeftColumn + "] " + joiner.Operator + " [" + joiner.RightTable + "].[" + joiner.RightColumn + "] AND "
	}
	// Remove the trailing AND
	querystr = querystr[0 : len(querystr)-4]

	// Add support for BETWEEN x.x
	if len(where) != 0 {
		querystr += " WHERE"
		for _, loc := range processWhere(where) {
			for _, token := range loc.Expr {
				switch token.Type {
				case "substitute":
					substituteCount++
					querystr += " ?" + strconv.Itoa(substituteCount)
				case "function", "operator", "number":
					// TODO: Split the function case off to speed things up
					if strings.ToUpper(token.Contents) == "UTC_TIMESTAMP()" {
						token.Contents = "GETUTCDATE()"
					}
					querystr += " " + token.Contents
				case "column":
					halves := strings.Split(token.Contents, ".")
					if len(halves) == 2 {
						querystr += " [" + halves[0] + "].[" + halves[1] + "]"
					} else {
						querystr += " [" + token.Contents + "]"
					}
				case "string":
					querystr += " '" + token.Contents + "'"
				default:
					panic("This token doesn't exist o_o")
				}
			}
			querystr += " AND"
		}
		querystr = querystr[0 : len(querystr)-4]
	}

	// TODO: MSSQL requires ORDER BY for LIMIT
	if len(orderby) != 0 {
		querystr += " ORDER BY "
		for _, column := range processOrderby(orderby) {
			log.Print("column: ", column)
			// TODO: We might want to escape this column
			querystr += column.Column + " " + strings.ToUpper(column.Order) + ","
		}
		querystr = querystr[0 : len(querystr)-1]
	} else if limit != "" {
		key, ok := adapter.keys[table1]
		if ok {
			log.Print("key: ", key)
			querystr += " ORDER BY [" + table1 + "].[" + key + "]"
		}
	}

	if limit != "" {
		limiter := processLimit(limit)
		if limiter.Offset != "" {
			if limiter.Offset == "?" {
				substituteCount++
				querystr += " OFFSET ?" + strconv.Itoa(substituteCount) + " ROWS"
			} else {
				querystr += " OFFSET " + limiter.Offset + " ROWS"
			}
		}

		// ! Does this work without an offset?
		if limiter.MaxCount != "" {
			if limiter.MaxCount == "?" {
				substituteCount++
				limiter.MaxCount = "?" + strconv.Itoa(substituteCount)
			}
			querystr += " FETCH NEXT " + limiter.MaxCount + " ROWS ONLY "
		}
	}

	querystr = strings.TrimSpace("SELECT " + querystr)
	// TODO: Run this on debug mode?
	if name[0] == '_' && limit == "" {
		log.Print(name+" query: ", querystr)
	}
	adapter.pushStatement(name, "select", querystr)
	return querystr, nil
}

func (adapter *MssqlAdapter) SimpleInsertSelect(name string, ins DBInsert, sel DBSelect) (string, error) {
	// TODO: More errors.
	// TODO: Add this to the MySQL adapter in order to make this problem more discoverable?
	if len(sel.Orderby) == 0 && sel.Limit != "" {
		return "", errors.New("Orderby needs to be set to use limit on Mssql")
	}

	/* Insert */
	var querystr = "INSERT INTO [" + ins.Table + "] ("

	// Escape the column names, just in case we've used a reserved keyword
	for _, column := range processColumns(ins.Columns) {
		if column.Type == "function" {
			querystr += column.Left + ","
		} else {
			querystr += "[" + column.Left + "],"
		}
	}
	querystr = querystr[0:len(querystr)-1] + ") SELECT "

	/* Select */
	var substituteCount = 0

	for _, column := range processColumns(sel.Columns) {
		var source, alias string

		// Escape the column names, just in case we've used a reserved keyword
		if column.Type == "function" || column.Type == "substitute" {
			source = column.Left
		} else {
			source = "[" + column.Left + "]"
		}

		if column.Alias != "" {
			alias = " AS [" + column.Alias + "]"
		}
		querystr += " " + source + alias + ","
	}
	querystr = querystr[0 : len(querystr)-1]
	querystr += " FROM [" + sel.Table + "] "

	// Add support for BETWEEN x.x
	if len(sel.Where) != 0 {
		querystr += " WHERE"
		for _, loc := range processWhere(sel.Where) {
			for _, token := range loc.Expr {
				switch token.Type {
				case "substitute":
					substituteCount++
					querystr += " ?" + strconv.Itoa(substituteCount)
				case "function", "operator", "number":
					// TODO: Split the function case off to speed things up
					if strings.ToUpper(token.Contents) == "UTC_TIMESTAMP()" {
						token.Contents = "GETUTCDATE()"
					}
					querystr += " " + token.Contents
				case "column":
					querystr += " [" + token.Contents + "]"
				case "string":
					querystr += " '" + token.Contents + "'"
				default:
					panic("This token doesn't exist o_o")
				}
			}
			querystr += " AND"
		}
		querystr = querystr[0 : len(querystr)-4]
	}

	// TODO: MSSQL requires ORDER BY for LIMIT
	if len(sel.Orderby) != 0 {
		querystr += " ORDER BY "
		for _, column := range processOrderby(sel.Orderby) {
			// TODO: We might want to escape this column
			querystr += column.Column + " " + strings.ToUpper(column.Order) + ","
		}
		querystr = querystr[0 : len(querystr)-1]
	} else if sel.Limit != "" {
		key, ok := adapter.keys[sel.Table]
		if ok {
			querystr += " ORDER BY [" + sel.Table + "].[" + key + "]"
		}
	}

	if sel.Limit != "" {
		limiter := processLimit(sel.Limit)
		if limiter.Offset != "" {
			if limiter.Offset == "?" {
				substituteCount++
				querystr += " OFFSET ?" + strconv.Itoa(substituteCount) + " ROWS"
			} else {
				querystr += " OFFSET " + limiter.Offset + " ROWS"
			}
		}

		// ! Does this work without an offset?
		if limiter.MaxCount != "" {
			if limiter.MaxCount == "?" {
				substituteCount++
				limiter.MaxCount = "?" + strconv.Itoa(substituteCount)
			}
			querystr += " FETCH NEXT " + limiter.MaxCount + " ROWS ONLY "
		}
	}

	querystr = strings.TrimSpace(querystr)
	// TODO: Run this on debug mode?
	if name[0] == '_' && sel.Limit == "" {
		log.Print(name+" query: ", querystr)
	}

	adapter.pushStatement(name, "insert", querystr)
	return querystr, nil
}

func (adapter *MssqlAdapter) simpleJoin(name string, ins DBInsert, sel DBJoin, joinType string) (string, error) {
	// TODO: More errors.
	// TODO: Add this to the MySQL adapter in order to make this problem more discoverable?
	if len(sel.Orderby) == 0 && sel.Limit != "" {
		return "", errors.New("Orderby needs to be set to use limit on Mssql")
	}

	/* Insert */
	var querystr = "INSERT INTO [" + ins.Table + "] ("

	// Escape the column names, just in case we've used a reserved keyword
	for _, column := range processColumns(ins.Columns) {
		if column.Type == "function" {
			querystr += column.Left + ","
		} else {
			querystr += "[" + column.Left + "],"
		}
	}
	querystr = querystr[0:len(querystr)-1] + ") SELECT "

	/* Select */
	var substituteCount = 0

	for _, column := range processColumns(sel.Columns) {
		var source, alias string

		// Escape the column names, just in case we've used a reserved keyword
		if column.Table != "" {
			source = "[" + column.Table + "].[" + column.Left + "]"
		} else if column.Type == "function" {
			source = column.Left
		} else {
			source = "[" + column.Left + "]"
		}

		if column.Alias != "" {
			alias = " AS '" + column.Alias + "'"
		}
		querystr += source + alias + ","
	}
	// Remove the trailing comma
	querystr = querystr[0 : len(querystr)-1]

	querystr += " FROM [" + sel.Table1 + "] " + joinType + " JOIN [" + sel.Table2 + "] ON "
	for _, joiner := range processJoiner(sel.Joiners) {
		querystr += "[" + joiner.LeftTable + "].[" + joiner.LeftColumn + "] " + joiner.Operator + " [" + joiner.RightTable + "].[" + joiner.RightColumn + "] AND "
	}
	// Remove the trailing AND
	querystr = querystr[0 : len(querystr)-4]

	// Add support for BETWEEN x.x
	if len(sel.Where) != 0 {
		querystr += " WHERE"
		for _, loc := range processWhere(sel.Where) {
			for _, token := range loc.Expr {
				switch token.Type {
				case "substitute":
					substituteCount++
					querystr += " ?" + strconv.Itoa(substituteCount)
				case "function", "operator", "number":
					// TODO: Split the function case off to speed things up
					if strings.ToUpper(token.Contents) == "UTC_TIMESTAMP()" {
						token.Contents = "GETUTCDATE()"
					}
					querystr += " " + token.Contents
				case "column":
					halves := strings.Split(token.Contents, ".")
					if len(halves) == 2 {
						querystr += " [" + halves[0] + "].[" + halves[1] + "]"
					} else {
						querystr += " [" + token.Contents + "]"
					}
				case "string":
					querystr += " '" + token.Contents + "'"
				default:
					panic("This token doesn't exist o_o")
				}
			}
			querystr += " AND"
		}
		querystr = querystr[0 : len(querystr)-4]
	}

	// TODO: MSSQL requires ORDER BY for LIMIT
	if len(sel.Orderby) != 0 {
		querystr += " ORDER BY "
		for _, column := range processOrderby(sel.Orderby) {
			log.Print("column: ", column)
			// TODO: We might want to escape this column
			querystr += column.Column + " " + strings.ToUpper(column.Order) + ","
		}
		querystr = querystr[0 : len(querystr)-1]
	} else if sel.Limit != "" {
		key, ok := adapter.keys[sel.Table1]
		if ok {
			querystr += " ORDER BY [" + sel.Table1 + "].[" + key + "]"
		}
	}

	if sel.Limit != "" {
		limiter := processLimit(sel.Limit)
		if limiter.Offset != "" {
			if limiter.Offset == "?" {
				substituteCount++
				querystr += " OFFSET ?" + strconv.Itoa(substituteCount) + " ROWS"
			} else {
				querystr += " OFFSET " + limiter.Offset + " ROWS"
			}
		}

		// ! Does this work without an offset?
		if limiter.MaxCount != "" {
			if limiter.MaxCount == "?" {
				substituteCount++
				limiter.MaxCount = "?" + strconv.Itoa(substituteCount)
			}
			querystr += " FETCH NEXT " + limiter.MaxCount + " ROWS ONLY "
		}
	}

	querystr = strings.TrimSpace(querystr)
	// TODO: Run this on debug mode?
	if name[0] == '_' && sel.Limit == "" {
		log.Print(name+" query: ", querystr)
	}

	adapter.pushStatement(name, "insert", querystr)
	return querystr, nil
}

func (adapter *MssqlAdapter) SimpleInsertLeftJoin(name string, ins DBInsert, sel DBJoin) (string, error) {
	return adapter.simpleJoin(name, ins, sel, "LEFT")
}

func (adapter *MssqlAdapter) SimpleInsertInnerJoin(name string, ins DBInsert, sel DBJoin) (string, error) {
	return adapter.simpleJoin(name, ins, sel, "INNER")
}

func (adapter *MssqlAdapter) SimpleCount(name string, table string, where string, limit string) (string, error) {
	if name == "" {
		return "", errors.New("You need a name for this statement")
	}
	if table == "" {
		return "", errors.New("You need a name for this table")
	}

	var querystr = "SELECT COUNT(*) AS [count] FROM [" + table + "]"

	// TODO: Add support for BETWEEN x.x
	if len(where) != 0 {
		querystr += " WHERE"
		for _, loc := range processWhere(where) {
			for _, token := range loc.Expr {
				switch token.Type {
				case "function", "operator", "number", "substitute":
					if strings.ToUpper(token.Contents) == "UTC_TIMESTAMP()" {
						token.Contents = "GETUTCDATE()"
					}
					querystr += " " + token.Contents
				case "column":
					querystr += " [" + token.Contents + "]"
				case "string":
					querystr += " '" + token.Contents + "'"
				default:
					panic("This token doesn't exist o_o")
				}
			}
			querystr += " AND"
		}
		querystr = querystr[0 : len(querystr)-4]
	}

	if limit != "" {
		querystr += " LIMIT " + limit
	}

	querystr = strings.TrimSpace(querystr)
	adapter.pushStatement(name, "select", querystr)
	return querystr, nil
}

func (adapter *MssqlAdapter) Select(nlist ...string) *selectPrebuilder {
	name := optString(nlist, "_builder")
	return &selectPrebuilder{name, "", "", "", "", "", adapter}
}

func (adapter *MssqlAdapter) Insert(nlist ...string) *insertPrebuilder {
	name := optString(nlist, "_builder")
	return &insertPrebuilder{name, "", "", "", adapter}
}

func (adapter *MssqlAdapter) Update(nlist ...string) *updatePrebuilder {
	name := optString(nlist, "_builder")
	return &updatePrebuilder{name, "", "", "", adapter}
}

func (adapter *MssqlAdapter) Delete(nlist ...string) *deletePrebuilder {
	name := optString(nlist, "_builder")
	return &deletePrebuilder{name, "", "", adapter}
}

func (adapter *MssqlAdapter) Write() error {
	var stmts, body string
	for _, name := range adapter.BufferOrder {
		if name[0] == '_' {
			continue
		}
		stmt := adapter.Buffer[name]
		// TODO: Add support for create-table? Table creation might be a little complex for Go to do outside a SQL file :(
		if stmt.Type != "create-table" {
			stmts += "\t" + name + " *sql.Stmt\n"
			body += `	
	log.Print("Preparing ` + name + ` statement.")
	stmts.` + name + `, err = db.Prepare("` + stmt.Contents + `")
	if err != nil {
		log.Print("Bad Query: ","` + stmt.Contents + `")
		return err
	}
	`
		}
	}

	// TODO: Move these custom queries out of this file
	out := `// +build mssql

// This file was generated by Gosora's Query Generator. Please try to avoid modifying this file, as it might change at any time.
package main

import "log"
import "database/sql"
import "./common"

// nolint
type Stmts struct {
` + stmts + `
	getActivityFeedByWatcher *sql.Stmt
	getActivityCountByWatcher *sql.Stmt
	todaysPostCount *sql.Stmt
	todaysTopicCount *sql.Stmt
	todaysReportCount *sql.Stmt
	todaysNewUserCount *sql.Stmt
	findUsersByIPUsers *sql.Stmt
	findUsersByIPTopics *sql.Stmt
	findUsersByIPReplies *sql.Stmt

	Mocks bool
}

// nolint
func _gen_mssql() (err error) {
	if common.Dev.DebugMode {
		log.Print("Building the generated statements")
	}
` + body + `
	return nil
}
`
	return writeFile("./gen_mssql.go", out)
}

// Internal methods, not exposed in the interface
func (adapter *MssqlAdapter) pushStatement(name string, stype string, querystr string) {
	adapter.Buffer[name] = DBStmt{querystr, stype}
	adapter.BufferOrder = append(adapter.BufferOrder, name)
}

func (adapter *MssqlAdapter) stringyType(ctype string) bool {
	ctype = strings.ToLower(ctype)
	return ctype == "char" || ctype == "varchar" || ctype == "datetime" || ctype == "text" || ctype == "nvarchar"
}

type SetPrimaryKeys interface {
	SetPrimaryKeys(keys map[string]string)
}

func (adapter *MssqlAdapter) SetPrimaryKeys(keys map[string]string) {
	adapter.keys = keys
}