package golingvu

import (
	"encoding/json"
	"fmt"
	"net"
	"os"
	"path/filepath"
	"strconv"
	"time"
)

type IFinalResults struct {
	Failed       bool
	Fails        int
	Artifacts    []interface{}
	Features     []string
	Tests        int
	RunTimeTests int
}

// PM_Golang implements the process manager for Go tests
type PM_Golang struct {
	testResourceConfiguration ITTestResourceConfiguration
	client                    net.Conn
}

// Stop closes the connection and cleans up resources
func (pm *PM_Golang) Stop() error {
	if pm.client != nil {
		err := pm.client.Close()
		pm.client = nil
		return err
	}
	return nil
}

func (pm *PM_Golang) Start() error {
	return nil
}

// WriteFileSync writes data to a file synchronously
func (pm *PM_Golang) WriteFileSync(
	filename string,
	data string,
	tr string,
) (bool, error) {
	fullPath := pm.testResourceConfiguration.Fs + "/" + filename
	result, err := pm.send("writeFileSync", fullPath, data, tr)
	if err != nil {
		return false, err
	}
	return result.(bool), nil
}

func (pm *PM_Golang) send(command string, args ...interface{}) (interface{}, error) {
	// Generate a unique key
	key := strconv.FormatInt(time.Now().UnixNano(), 10)

	// Create the message array
	message := []interface{}{command}
	message = append(message, args...)
	message = append(message, key)

	// Convert to JSON
	data, err := json.Marshal(message)
	if err != nil {
		fmt.Printf("JSON marshal error: %v\n", err)
		return nil, err
	}

	fmt.Printf("Sending message: %s\n", string(data))

	// Check if client is connected
	if pm.client == nil {
		fmt.Println("Client is nil - cannot send")
		return nil, fmt.Errorf("client is not connected")
	}

	// Send the length first (4-byte big-endian)
	length := uint32(len(data))
	lengthBytes := []byte{
		byte(length >> 24),
		byte(length >> 16),
		byte(length >> 8),
		byte(length),
	}

	_, err = pm.client.Write(lengthBytes)
	if err != nil {
		fmt.Printf("Error writing length: %v\n", err)
		return nil, err
	}

	// Send the actual data
	_, err = pm.client.Write(data)
	if err != nil {
		fmt.Printf("Error writing data: %v\n", err)
		return nil, err
	}

	// Wait for response
	// First read the length
	lengthBytes = make([]byte, 4)
	_, err = pm.client.Read(lengthBytes)
	if err != nil {
		fmt.Printf("Error reading length: %v\n", err)
		return nil, err
	}

	length = uint32(lengthBytes[0])<<24 | uint32(lengthBytes[1])<<16 |
		uint32(lengthBytes[2])<<8 | uint32(lengthBytes[3])

	fmt.Printf("Response length: %d\n", length)

	// Read the response data
	responseData := make([]byte, length)
	_, err = pm.client.Read(responseData)
	if err != nil {
		fmt.Printf("Error reading response data: %v\n", err)
		return nil, err
	}

	fmt.Printf("Response data: %s\n", string(responseData))

	// Parse the response
	var response map[string]interface{}
	err = json.Unmarshal(responseData, &response)
	if err != nil {
		fmt.Printf("JSON unmarshal error: %v\n", err)
		return nil, err
	}

	// Check if the response key matches our request key
	if responseKey, ok := response["key"].(string); ok && responseKey == key {
		return response["payload"], nil
	}

	fmt.Printf("Key mismatch: expected %s, got %v\n", key, response["key"])
	return nil, fmt.Errorf("key mismatch in response")
}

// Implement all the PM methods to match Node and Python implementations
func (pm *PM_Golang) Pages() ([]string, error) {
	result, err := pm.send("pages")
	if err != nil {
		return nil, err
	}
	return result.([]string), nil
}

func (pm *PM_Golang) WaitForSelector(page, selector string) (interface{}, error) {
	return pm.send("waitForSelector", page, selector)
}

func (pm *PM_Golang) ClosePage(page interface{}) (interface{}, error) {
	return pm.send("closePage", page)
}

func (pm *PM_Golang) Goto(page, url string) (interface{}, error) {
	return pm.send("goto", page, url)
}

func (pm *PM_Golang) NewPage() (string, error) {
	result, err := pm.send("newPage")
	if err != nil {
		return "", err
	}
	return result.(string), nil
}

func (pm *PM_Golang) Selector(selector, page string) (interface{}, error) {
	return pm.send("$", selector, page)
}

func (pm *PM_Golang) IsDisabled(selector string) (bool, error) {
	result, err := pm.send("isDisabled", selector)
	if err != nil {
		return false, err
	}
	return result.(bool), nil
}

func (pm *PM_Golang) GetAttribute(selector, attribute, page string) (interface{}, error) {
	return pm.send("getAttribute", selector, attribute, page)
}

func (pm *PM_Golang) GetInnerHtml(selector, page string) (interface{}, error) {
	return pm.send("getInnerHtml", selector, page)
}

func (pm *PM_Golang) FocusOn(selector string) (interface{}, error) {
	return pm.send("focusOn", selector)
}

func (pm *PM_Golang) TypeInto(selector string) (interface{}, error) {
	return pm.send("typeInto", selector)
}

func (pm *PM_Golang) Page() (string, error) {
	result, err := pm.send("page")
	if err != nil {
		return "", err
	}
	return result.(string), nil
}

func (pm *PM_Golang) Click(selector string) (interface{}, error) {
	return pm.send("click", selector)
}

func (pm *PM_Golang) Screencast(opts map[string]interface{}, page string) (interface{}, error) {
	return pm.send("screencast", opts, page, pm.testResourceConfiguration.Name)
}

func (pm *PM_Golang) ScreencastStop(page string) (interface{}, error) {
	return pm.send("screencastStop", page)
}

func (pm *PM_Golang) CustomScreenshot(opts map[string]interface{}, page string) (interface{}, error) {
	return pm.send("customScreenShot", opts, pm.testResourceConfiguration.Name, page)
}

func (pm *PM_Golang) ExistsSync(destFolder string) (bool, error) {
	path := pm.testResourceConfiguration.Fs + "/" + destFolder
	result, err := pm.send("existsSync", path)
	if err != nil {
		return false, err
	}
	return result.(bool), nil
}

func (pm *PM_Golang) MkdirSync() (interface{}, error) {
	path := pm.testResourceConfiguration.Fs + "/"
	return pm.send("mkdirSync", path)
}

func (pm *PM_Golang) Write(uid int, contents string) (bool, error) {
	result, err := pm.send("write", uid, contents)
	if err != nil {
		return false, err
	}
	return result.(bool), nil
}

func (pm *PM_Golang) CreateWriteStream(filepath string) (string, error) {
	fullPath := pm.testResourceConfiguration.Fs + "/" + filepath
	result, err := pm.send("createWriteStream", fullPath, pm.testResourceConfiguration.Name)
	if err != nil {
		return "", err
	}
	return result.(string), nil
}

func (pm *PM_Golang) End(uid interface{}) (bool, error) {
	result, err := pm.send("end", uid)
	if err != nil {
		return false, err
	}
	return result.(bool), nil
}

func (pm *PM_Golang) CustomClose() (interface{}, error) {
	return pm.send("customclose", pm.testResourceConfiguration.Fs, pm.testResourceConfiguration.Name)
}

func (pm *PM_Golang) TestArtiFactoryfileWriter(tLog func(...interface{}), callback func(promise interface{})) interface{} {
	// This would need to be implemented to match the Node.js implementation
	// For now, return a placeholder
	return func(fPath string, value interface{}) {
		// Implementation would go here
	}
}

// ITestJob represents a test job
type ITestJob interface {
	ToObj() map[string]interface{}
	Runner(pm interface{}, tLog func(...string)) (interface{}, error)
	ReceiveTestResourceConfig(pm interface{}) (IFinalResults, error)
}

// Golingvu is the main test runner class (Go implementation of Tiposkripto)
type Golingvu struct {
	TestResourceRequirement ITTestResourceRequest
	Artifacts               []interface{}
	TestJobs                []ITestJob
	TestSpecification       ITestSpecification
	SuitesOverrides         map[string]interface{}
	GivenOverrides          map[string]interface{}
	WhenOverrides           map[string]interface{}
	ThenOverrides           map[string]interface{}
	PuppetMaster            interface{}
	Specs                   interface{}
	totalTests              int
	assertThis              func(t interface{}) interface{}
}

// NewPM_Golang creates a new PM_Golang instance
func NewPM_Golang(t ITTestResourceConfiguration, ipcFile string) (*PM_Golang, error) {
	// Connect to the IPC socket
	fmt.Printf("Attempting to connect to IPC file: %s\n", ipcFile)
	conn, err := net.Dial("unix", ipcFile)
	if err != nil {
		fmt.Printf("Failed to connect to IPC file %s: %v\n", ipcFile, err)
		return nil, fmt.Errorf("failed to connect to IPC file %s: %v", ipcFile, err)
	}

	fmt.Printf("Successfully connected to IPC file: %s\n", ipcFile)
	return &PM_Golang{
		testResourceConfiguration: t,
		client:                    conn,
	}, nil
}

// NewGolingvu creates a new Golingvu instance
func NewGolingvu(
	input interface{},
	testSpecification ITestSpecification,
	testImplementation ITestImplementation,
	testResourceRequirement ITTestResourceRequest,
	testAdapter ITestAdapter,
	uberCatcher func(func()),
) *Golingvu {
	gv := &Golingvu{
		TestResourceRequirement: testResourceRequirement,
		Artifacts:               make([]interface{}, 0),
		SuitesOverrides:         make(map[string]interface{}),
		GivenOverrides:          make(map[string]interface{}),
		WhenOverrides:           make(map[string]interface{}),
		ThenOverrides:           make(map[string]interface{}),
		assertThis: func(t interface{}) interface{} {
			return testAdapter.AssertThis(t)
		},
	}

	// Create classy implementations as functions that return instances
	classySuites := make(map[string]interface{})
	for key := range testImplementation.Suites {
		classySuites[key] = func(somestring string, givens map[string]*BaseGiven) *BaseSuite {
			return &BaseSuite{
				Key:    somestring,
				Givens: givens,
				AfterAllFunc: func(store interface{}, artifactory func(string, interface{}), pm interface{}) interface{} {
					return testAdapter.AfterAll(store, pm)
				},
				AssertThatFunc: func(t interface{}) bool {
					return testAdapter.AssertThis(t)
				},
				SetupFunc: func(s interface{}, artifactory func(string, interface{}), tr ITTestResourceConfiguration, pm interface{}) interface{} {
					result := testAdapter.BeforeAll(s, tr, pm)
					if result == nil {
						return s
					}
					return result
				},
			}
		}
	}

	classyGivens := make(map[string]interface{})
	for key, g := range testImplementation.Givens {
		// Capture the current values
		givenCB := g
		classyGivens[key] = func(key string, features []string, whens []*BaseWhen, thens []*BaseThen, gcb interface{}, initialValues interface{}) *BaseGiven {
			return &BaseGiven{
				Key:           key,
				Features:      features,
				Whens:         whens,
				Thens:         thens,
				GivenCB:       givenCB,
				InitialValues: initialValues,
				Artifacts:     make([]string, 0),
				GivenThatFunc: func(subject, testResource, artifactory, initializer, initialValues, pm interface{}) (interface{}, error) {
					// Type assertion for testResource
					tr, ok := testResource.(ITTestResourceConfiguration)
					if !ok {
						return nil, nil
					}
					return testAdapter.BeforeEach(subject, initializer, tr, initialValues, pm), nil
				},
				AfterEachFunc: func(store interface{}, key string, artifactory, pm interface{}) (interface{}, error) {
					return testAdapter.AfterEach(store, key, pm), nil
				},
				UberCatcherFunc: uberCatcher,
			}
		}
	}

	classyWhens := make(map[string]interface{})
	for key, whEn := range testImplementation.Whens {
		// Capture the current values
		whenKey := key
		whenCB := whEn
		classyWhens[key] = func(payload ...interface{}) *BaseWhen {
			return &BaseWhen{
				Key:    whenKey,
				WhenCB: whenCB,
				AndWhenFunc: func(store, whenCB, testResource, pm interface{}) (interface{}, error) {
					return testAdapter.AndWhen(store, whenCB, testResource, pm), nil
				},
			}
		}
	}

	classyThens := make(map[string]interface{})
	for key, thEn := range testImplementation.Thens {
		// Capture the current values
		thenKey := key
		thenCB := thEn
		classyThens[key] = func(args ...interface{}) *BaseThen {
			return &BaseThen{
				Key:    thenKey,
				ThenCB: thenCB,
				ButThenFunc: func(store, thenCB, testResource, pm interface{}) (interface{}, error) {
					return testAdapter.ButThen(store, thenCB, testResource, pm), nil
				},
			}
		}
	}

	// Set up the overrides
	gv.SuitesOverrides = classySuites
	gv.GivenOverrides = classyGivens
	gv.WhenOverrides = classyWhens
	gv.ThenOverrides = classyThens
	gv.TestResourceRequirement = testResourceRequirement
	gv.TestSpecification = testSpecification

	// Generate specs
	specs := testSpecification(
		gv.Suites(),
		gv.Given(),
		gv.When(),
		gv.Then(),
	)

	// Ensure specs is properly formatted as a slice
	if specsSlice, ok := specs.([]interface{}); ok {
		gv.Specs = specsSlice
	} else {
		// If it's not a slice, wrap it in one
		gv.Specs = []interface{}{specs}
	}

	// Calculate total number of tests (sum of all Givens across all Suites)
	// This needs to be implemented based on the actual structure
	// For now, we'll set a placeholder
	gv.totalTests = 0
	// Implementation to count Givens would go here

	// Create test jobs based on the specifications
	gv.TestJobs = make([]ITestJob, 0)
	gv.totalTests = 0

	// Parse the specs to create test jobs
	if specs, ok := gv.Specs.([]interface{}); ok {
		for _, suite := range specs {
			if suiteMap, ok := suite.(map[string]interface{}); ok {
				if givensMap, exists := suiteMap["givens"].(map[string]interface{}); exists {
					for key := range givensMap {
						gv.TestJobs = append(gv.TestJobs, &BaseTestJob{
							Name: key,
						})
						gv.totalTests++
					}
				}
			}
		}
	}

	// If no test jobs were created, add a default one
	if len(gv.TestJobs) == 0 {
		gv.TestJobs = append(gv.TestJobs, &BaseTestJob{
			Name: "DefaultTest",
		})
		gv.totalTests = 1
	}

	return gv
}

// ReceiveTestResourceConfig receives test resource configuration and executes tests
func (gv *Golingvu) ReceiveTestResourceConfig(partialTestResource string, pm interface{}) (IFinalResults, error) {
	// Parse the test resource configuration
	var testResourceConfig ITTestResourceConfiguration
	err := json.Unmarshal([]byte(partialTestResource), &testResourceConfig)
	if err != nil {
		return IFinalResults{
			Failed:       true,
			Fails:        -1,
			Artifacts:    []interface{}{},
			Features:     []string{},
			Tests:        0,
			RunTimeTests: -1,
		}, err
	}

	// Run the actual tests and capture results
	testResults, err := gv.runActualTests()

	if err != nil {
		return IFinalResults{
			Failed:       true,
			Fails:        -1,
			Artifacts:    []interface{}{},
			Features:     []string{},
			Tests:        0,
			RunTimeTests: -1,
		}, fmt.Errorf("failed to run tests: %v", err)
	}

	// Write tests.json via PM
	if pm == nil {
		return IFinalResults{
			Failed:       true,
			Fails:        -1,
			Artifacts:    []interface{}{},
			Features:     []string{},
			Tests:        0,
			RunTimeTests: -1,
		}, fmt.Errorf("PM is required to write tests.json")
	}

	// Try to cast to PM_Golang to access WriteFileSync
	pmGolang, ok := pm.(*PM_Golang)
	if !ok {
		return IFinalResults{
			Failed:       true,
			Fails:        -1,
			Artifacts:    []interface{}{},
			Features:     []string{},
			Tests:        0,
			RunTimeTests: -1,
		}, fmt.Errorf("invalid PM type")
	}

	data, err := json.MarshalIndent(testResults, "", "  ")
	if err != nil {
		return IFinalResults{
			Failed:       true,
			Fails:        -1,
			Artifacts:    []interface{}{},
			Features:     []string{},
			Tests:        0,
			RunTimeTests: -1,
		}, fmt.Errorf("failed to marshal tests.json: %v", err)
	}

	_, err = pmGolang.WriteFileSync("tests.json", string(data), "test")
	if err != nil {
		return IFinalResults{
			Failed:       true,
			Fails:        -1,
			Artifacts:    []interface{}{},
			Features:     []string{},
			Tests:        0,
			RunTimeTests: -1,
		}, fmt.Errorf("failed to write tests.json via PM: %v", err)
	}

	// Calculate total fails from test results
	totalFails := 0
	if fails, exists := testResults["fails"].(int); exists {
		totalFails = fails
	}

	result := IFinalResults{
		Failed:       totalFails > 0,
		Fails:        totalFails,
		Artifacts:    []interface{}{},
		Features:     []string{},
		Tests:        gv.totalTests,
		RunTimeTests: gv.totalTests,
	}

	return result, nil
}

// runActualTests executes the actual test jobs and returns results matching Node.js format
func (gv *Golingvu) runActualTests() (map[string]interface{}, error) {
	// Create the structure that matches the Node.js implementation exactly
	results := make(map[string]interface{})

	// Initialize the results structure with proper types
	results["givens"] = make([]interface{}, 0)
	results["features"] = make([]string, 0)

	// Track total failures
	totalFails := 0

	// Parse the specs and actually execute the tests
	if specs, ok := gv.Specs.([]interface{}); ok {
		for _, suite := range specs {
			if suiteMap, ok := suite.(map[string]interface{}); ok {
				// Set the key from the suite
				if suiteName, exists := suiteMap["key"].(string); exists {
					results["key"] = suiteName
				}

				// Process givens
				if givensMap, exists := suiteMap["givens"].(map[string]interface{}); exists {
					for key, given := range givensMap {
						if givenObj, ok := given.(*BaseGiven); ok {
							// Execute the test and record actual results
							processedGiven, testFailed, err := gv.executeTest(key, givenObj)
							if err != nil {
								return nil, err
							}

							if testFailed {
								totalFails++
							}

							// Add to results
							givensSlice := results["givens"].([]interface{})
							results["givens"] = append(givensSlice, processedGiven)

							// Add features to overall features (deduplicated)
							if features, exists := processedGiven["features"].([]string); exists {
								existingFeatures := results["features"].([]string)
								featureSet := make(map[string]bool)

								// Add existing features to set
								for _, feature := range existingFeatures {
									featureSet[feature] = true
								}

								// Add new features
								for _, feature := range features {
									if !featureSet[feature] {
										existingFeatures = append(existingFeatures, feature)
										featureSet[feature] = true
									}
								}
								results["features"] = existingFeatures
							}
						}
					}
				}
			}
		}
	}

	results["fails"] = totalFails

	return results, nil
}

// executeTest actually runs a test and records its results to match Node.js format
func (gv *Golingvu) executeTest(key string, given *BaseGiven) (map[string]interface{}, bool, error) {
	// Create the test result structure that matches the Node.js format exactly
	processedGiven := map[string]interface{}{
		"key":       key,
		"whens":     []map[string]interface{}{},
		"thens":     []map[string]interface{}{},
		"error":     nil,
		"features":  given.Features,
		"artifacts": []interface{}{},
		"status":    true, // Default to true, will be set to false if any step fails
	}

	// Track if the test failed
	testFailed := false

	// Process whens - execute each when step
	for _, when := range given.Whens {
		// Execute the when callback if it exists
		var whenError error = nil
		var whenName string = when.Key

		// Record the when step according to the Node.js format
		processedWhen := map[string]interface{}{
			"key":       whenName,
			"status":    whenError == nil,
			"error":     whenError,
			"artifacts": []interface{}{},
		}
		// Convert to the right type
		whensSlice := processedGiven["whens"].([]map[string]interface{})
		processedGiven["whens"] = append(whensSlice, processedWhen)

		if whenError != nil {
			testFailed = true
			processedGiven["status"] = false
			processedGiven["error"] = whenError
		}
	}

	// Process thens - execute each then step
	for _, then := range given.Thens {
		// Execute the then callback if it exists
		var thenError error = nil
		var thenName string = then.Key
		var thenStatus bool = true

		// Record the then step according to the Node.js format
		processedThen := map[string]interface{}{
			"key":       thenName,
			"error":     thenError != nil,
			"artifacts": []interface{}{},
			"status":    thenStatus,
		}
		// Convert to the right type
		thensSlice := processedGiven["thens"].([]map[string]interface{})
		processedGiven["thens"] = append(thensSlice, processedThen)

		if thenError != nil {
			testFailed = true
			processedGiven["status"] = false
			if processedGiven["error"] == nil {
				processedGiven["error"] = thenError
			}
		}
	}

	return processedGiven, testFailed, nil
}

// Suites returns the suites overrides
func (gv *Golingvu) Suites() map[string]interface{} {
	return gv.SuitesOverrides
}

// Given returns the given overrides
func (gv *Golingvu) Given() map[string]interface{} {
	return gv.GivenOverrides
}

// When returns the when overrides
func (gv *Golingvu) When() map[string]interface{} {
	return gv.WhenOverrides
}

// Then returns the then overrides
func (gv *Golingvu) Then() map[string]interface{} {
	return gv.ThenOverrides
}

// GetTestJobs returns the test jobs
func (gv *Golingvu) GetTestJobs() []ITestJob {
	return gv.TestJobs
}

// GetSpecs returns the generated specs
func (gv *Golingvu) GetSpecs() interface{} {
	return gv.Specs
}

// AssertThis is a helper function for assertions
func (gv *Golingvu) AssertThis(t interface{}) interface{} {
	return gv.assertThis(t)
}

// BaseTestJob implements ITestJob for basic test execution
type BaseTestJob struct {
	Name string
}

func (bj *BaseTestJob) ToObj() map[string]interface{} {
	return map[string]interface{}{
		"key": bj.Name,
	}
}

func (bj *BaseTestJob) Runner(pm interface{}, tLog func(...string)) (interface{}, error) {
	// Log that we're running the test
	if tLog != nil {
		tLog("Running test:", bj.Name)
	}

	// For now, we'll return a result that matches the Node.js test structure
	// This should include detailed information about whens and thens
	// In a real implementation, this would execute the actual test steps

	// Based on the Node.js results, each test has:
	// key, whens, thens, error, features, artifacts
	result := map[string]interface{}{
		"key":       bj.Name,
		"whens":     []map[string]interface{}{},
		"thens":     []map[string]interface{}{},
		"error":     nil,
		"features":  []string{},
		"artifacts": []interface{}{},
	}

	return result, nil
}

func (bj *BaseTestJob) ReceiveTestResourceConfig(pm interface{}) (IFinalResults, error) {

	fmt.Println("ReceiveTestResourceConfig")

	// Execute the test using the runner
	tLog := func(messages ...string) {
		// Simple logging function
		for _, msg := range messages {
			fmt.Println(msg)
		}
	}

	// Run the test
	result, err := bj.Runner(pm, tLog)
	if err != nil {
		return IFinalResults{
			Failed:       true,
			Fails:        1,
			Artifacts:    []interface{}{},
			Features:     []string{},
			Tests:        1,
			RunTimeTests: 1,
		}, err
	}

	// Check if the test passed or failed by looking at the thens
	failed := false
	if resultMap, ok := result.(map[string]interface{}); ok {
		// Check each then for errors
		if thens, exists := resultMap["thens"].([]map[string]interface{}); exists {
			for _, then := range thens {
				if thenError, exists := then["error"].(bool); exists && thenError {
					failed = true
					break
				}
			}
		}
	}

	return IFinalResults{
		Failed:       failed,
		Fails:        boolToInt(failed),
		Artifacts:    []interface{}{},
		Features:     []string{},
		Tests:        1,
		RunTimeTests: 1,
	}, nil
}

// Helper function to convert bool to int
func boolToInt(b bool) int {
	if b {
		return 1
	}
	return 0
}

// Helper function to write a file directly (fallback)
func writeFileDirectly(path string, content string) error {
	// Create directory if it doesn't exist
	dir := filepath.Dir(path)
	err := os.MkdirAll(dir, 0755)
	if err != nil {
		return err
	}

	// Write the file
	return os.WriteFile(path, []byte(content), 0644)
}

// Helper function to read a file directly
func readFileDirectly(path string) (string, error) {
	content, err := os.ReadFile(path)
	if err != nil {
		return "", err
	}
	return string(content), nil
}