package lang

import (
	"testing"
)

func TestParseServerDefinitions(t *testing.T) {
	tests := []struct {
		name    string
		input   string
		want    AST
		wantErr bool
	}{
		{
			name: "simple server definition with block delimiters",
			input: `server MyApp {
				host "localhost"
				port 8080
			}`,
			want: AST{
				Definitions: []Definition{
					{
						Server: &Server{
							Name: "MyApp",
							Settings: []ServerSetting{
								{Host: stringPtr("localhost")},
								{Port: intPtr(8080)},
							},
						},
					},
				},
			},
			wantErr: false,
		},
		{
			name: "server with only host setting",
			input: `server WebApp {
				host "0.0.0.0"
			}`,
			want: AST{
				Definitions: []Definition{
					{
						Server: &Server{
							Name: "WebApp",
							Settings: []ServerSetting{
								{Host: stringPtr("0.0.0.0")},
							},
						},
					},
				},
			},
			wantErr: false,
		},
		{
			name: "server with only port setting",
			input: `server APIServer {
				port 3000
			}`,
			want: AST{
				Definitions: []Definition{
					{
						Server: &Server{
							Name: "APIServer",
							Settings: []ServerSetting{
								{Port: intPtr(3000)},
							},
						},
					},
				},
			},
			wantErr: false,
		},
		{
			name:  "server without settings block",
			input: `server SimpleServer`,
			want: AST{
				Definitions: []Definition{
					{
						Server: &Server{
							Name:     "SimpleServer",
							Settings: []ServerSetting{},
						},
					},
				},
			},
			wantErr: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := ParseInput(tt.input)
			if (err != nil) != tt.wantErr {
				t.Errorf("ParseInput() error = %v, wantErr %v", err, tt.wantErr)
				return
			}

			if !tt.wantErr && !astEqual(got, tt.want) {
				t.Errorf("ParseInput() mismatch.\nGot: %+v\nWant: %+v", got, tt.want)
			}
		})
	}
}