package airport_test

import (
	"fmt"
	"reflect"
	"testing"
	"time"

	"gitty.informatik.hs-mannheim.de/steger/pr3-code/go/06-airport/airport"
)

type FlightProviderStub struct {
}

func (fps FlightProviderStub) GetFlight(fn airport.FlightNumber) (airport.Flight, error) {
	if fn == "LH123" {
		return airport.Flight{"LH123", "FRA", airport.GateNumber(1), time.Now(), time.Now()}, nil
	}
	return airport.Flight{}, fmt.Errorf("unknown flight %v", fn)
}

var _ airport.FlightProvider = FlightProviderStub{}

func TestCheckin(t *testing.T) {

	fp := FlightProviderStub{}
	bps := BaggageProcessorSpy{}
	sut := airport.NewCheckin(1*time.Millisecond, &fp, &bps)
	go sut.Start()

	testCases := []struct {
		name               string
		passenger          airport.Passenger
		expectErr          bool
		expectBaggage      []airport.Baggage
		expectBoardingpass *airport.BoardingPass
		expectBPSBaggage   []airport.Baggage
	}{
		{
			name: "Valid passenger with valid flight",
			passenger: airport.Passenger{
				"Max Mustermann",
				airport.Ticket{"Max Mustermann", "FRA", "LH123"},
				nil,
				[]airport.Baggage{{[]string{"Socks", "Shirts"}}},
				[]string{},
			},
			expectErr:          false,
			expectBaggage:      []airport.Baggage{},
			expectBoardingpass: &airport.BoardingPass{airport.Ticket{"Max Mustermann", "FRA", "LH123"}, airport.GateNumber(1)},
			expectBPSBaggage:   []airport.Baggage{{[]string{"Socks", "Shirts"}}},
		},
		{
			name: "Passenger with unknown flight",
			passenger: airport.Passenger{
				"John Doe",
				airport.Ticket{"John Doe", "MUC", "LH999"},
				nil,
				[]airport.Baggage{{[]string{"Socks", "Shirts"}}},
				[]string{},
			},
			expectErr:          true,
			expectBaggage:      []airport.Baggage{{[]string{"Socks", "Shirts"}}},
			expectBoardingpass: nil,
			expectBPSBaggage:   []airport.Baggage{},
		},
		{
			name: "Passenger with wrong ticket",
			passenger: airport.Passenger{
				"Max Mustermann",
				airport.Ticket{"Someone else", "FRA", "LH123"},
				nil,
				[]airport.Baggage{{[]string{"Socks", "Shirts"}}},
				[]string{},
			},
			expectErr:          true,
			expectBaggage:      []airport.Baggage{{[]string{"Socks", "Shirts"}}},
			expectBoardingpass: nil,
			expectBPSBaggage:   []airport.Baggage{},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			bps.Baggage = []BaggageSpyData{}

			start := time.Now()
			err := sut.Process(&tc.passenger)

			if elapsed := time.Since(start); elapsed < 1*time.Millisecond {
				t.Errorf("processing time too short: got %v, want at least 1ms", elapsed)
			}

			if (err != nil) != tc.expectErr {
				t.Errorf("expected error: %v, got: %v", tc.expectErr, err != nil)
			}

			if !reflect.DeepEqual(tc.passenger.BoardingPass, tc.expectBoardingpass) {
				t.Errorf("expected boarding pass: %v, got: %v", tc.expectBoardingpass, tc.passenger.BoardingPass)
			}

			if !reflect.DeepEqual(tc.passenger.Bags, tc.expectBaggage) {
				t.Errorf("expected baggage: %v, got: %v", tc.expectBaggage, tc.passenger.Bags)
			}

			gotBPSBaggage := []airport.Baggage{}
			for _, b := range bps.Baggage {
				gotBPSBaggage = append(gotBPSBaggage, b.b)
			}

			if !reflect.DeepEqual(gotBPSBaggage, tc.expectBPSBaggage) {
				t.Errorf("expected baggage processor baggage: %v, got: %v", tc.expectBPSBaggage, gotBPSBaggage)
			}
		})
	}
}