package q

import (
	"fmt"
	"testing"
)

type ParsingTest struct {
	input    string
	expected Select
}

func TestParseSelectStatement(t *testing.T) {
	var testSqlStatements = []ParsingTest{
		{
			input: "SELECT * FROM  users WHERE age >= 30",
			expected: Select{
				Table:      "users",
				IsWildcard: true,
				Conditionals: []Conditional{
					{
						Key:      "age",
						Operator: ">=",
						Value:    "30",
					},
				},
			},
		},
		{
			input: "SELECT CustomerName, City FROM Customers",
			expected: Select{
				Table:      "Customers",
				IsWildcard: false,
				Columns: []string{
					"CustomerName",
					"City",
				},
			},
		},
		{
			input: "SELECT DISTINCT Country FROM Nations;",
			expected: Select{
				Table: "Nations",
				Columns: []string{
					"Country",
				},
			},
		},
		{
			input: "SELECT * FROM Orders ORDER BY StreetNumber, CountryCode;",
			expected: Select{
				Table:      "Orders",
				IsWildcard: true,
				OrderBys: []OrderBy{
					{
						Key: "StreetNumber",
					},
					{
						Key: "CountryCode",
					},
				},
			},
		},
		{
			input: "SELECT * FROM ZipCodes ORDER BY Code ASC, StateName DESC",
			expected: Select{
				Table:      "ZipCodes",
				IsWildcard: true,
				OrderBys: []OrderBy{
					{
						Key:       "Code",
						IsDescend: false,
					},
					{
						Key:       "StateName",
						IsDescend: true,
					},
				},
			},
		},
		{
			input: "SELECT id, streetNumber, streetName, city, state FROM Addresses WHERE state = 'AL' AND zip > 9000 ORDER BY zip DESC, streetNumber",
			expected: Select{
				Table:      "Addresses",
				IsWildcard: false,
				Columns:    []string{"id", "streetNumber", "streetName", "city", "state"},
				Conditionals: []Conditional{
					{
						Key:      "state",
						Operator: "=",
						Value:    "'AL'",
					},
					{
						Key:       "zip",
						Operator:  ">",
						Value:     "9000",
						Extension: "AND",
					},
				},
				OrderBys: []OrderBy{
					{
						Key:       "zip",
						IsDescend: true,
					},
					{
						Key:       "streetNumber",
						IsDescend: false,
					},
				},
			},
		},
	}

	for _, sql := range testSqlStatements {
		testName := fmt.Sprintf("%s", sql.input)
		expected := sql.expected

		t.Run(testName, func(t *testing.T) {
			answer := ParseSelectStatement(sql.input)

			if answer.Table != expected.Table {
				t.Errorf("got %s for Select.Table, expected %s", answer.Table, expected.Table)
			}
			if answer.IsWildcard != expected.IsWildcard {
				t.Errorf("got %#v for Select.IsWildcard, expected %#v", answer.IsWildcard, expected.IsWildcard)
			}
			if len(answer.Columns) != len(expected.Columns) {
				t.Errorf("got %d number of columns for Select.Columns, expected %d", len(answer.Columns), len(expected.Columns))
			} else {
				for i, expectedColumn := range expected.Columns {
					if expectedColumn != answer.Columns[i] {
						t.Errorf("got %s for Select.Column[%d], expected %s", answer.Columns[i], i, expectedColumn)
					}
				}
			}

			if len(answer.Conditionals) != len(expected.Conditionals) {
				t.Errorf("got %d number of conditionals for Select.Conditionals, expected %d", len(answer.Conditionals), len(expected.Conditionals))
			} else {
				for i, expectedCondition := range expected.Conditionals {
					if expectedCondition.Key != answer.Conditionals[i].Key {
						t.Errorf("got %s for Select.Conditionals[%d].Key, expected %s", answer.Conditionals[i].Key, i, expectedCondition.Key)
					}
					if expectedCondition.Operator != answer.Conditionals[i].Operator {
						t.Errorf("got %s for Select.Conditionals[%d].Operator, expected %s", answer.Conditionals[i].Operator, i, expectedCondition.Operator)
					}
					if expectedCondition.Value != answer.Conditionals[i].Value {
						t.Errorf("got %s for Select.Conditionals[%d].Value, expected %s", answer.Conditionals[i].Value, i, expectedCondition.Value)
					}
					if expectedCondition.DataType != answer.Conditionals[i].DataType {
						t.Errorf("got %s for Select.Conditionals[%d].DataType, expected %s", answer.Conditionals[i].DataType, i, expectedCondition.DataType)
					}
					if expectedCondition.Extension != answer.Conditionals[i].Extension {
						t.Errorf("got %s for Select.Conditionals[%d].Extension, expected %s", answer.Conditionals[i].Extension, i, expectedCondition.Extension)
					}
				}
			}

			if len(answer.OrderBys) != len(expected.OrderBys) {
				t.Errorf("got %d number of orderBys for Select.OrderBys, expected %d", len(answer.OrderBys), len(expected.OrderBys))
			} else {
				for i, expectedOrderBy := range expected.OrderBys {
					if expectedOrderBy.Key != answer.OrderBys[i].Key {
						t.Errorf("got %s for Select.OrderBys[%d].Key, expected %s", answer.OrderBys[i].Key, i, expectedOrderBy.Key)
					}
					if expectedOrderBy.IsDescend != answer.OrderBys[i].IsDescend {
						t.Errorf("got %#v for Select.OrderBys[%d].IsDescend, expected %#v", answer.OrderBys[i].IsDescend, i, expectedOrderBy.IsDescend)
					}
				}
			}

		})
	}
}