Calculates eco friendly travel routes balancing time, cost, and emissions Go

```go
package main

import (
	"fmt"
	"math"
	"sort"
)

// Route represents a possible travel route between two locations.
type Route struct {
	Origin      string
	Destination string
	Mode        string // e.g., "train", "car", "plane", "bus"
	Time        float64 // Travel time in hours
	Cost        float64 // Travel cost in USD
	Emissions   float64 // CO2 emissions in kg
}

// Heuristic function to estimate the distance between two cities (simplified).
// In a real application, this would use a geo-location library or API.
func heuristic(origin, destination string) float64 {
	// Replace with actual distance calculations.  This is just a stub.
	distanceMap := map[string]map[string]float64{
		"London": {
			"Paris":     450, // km
			"Berlin":    930, // km
			"New York":  5585, // km
		},
		"Paris": {
			"London":    450, // km
			"Berlin":    878, // km
			"New York":  5835, // km
		},
		"Berlin": {
			"London":    930, // km
			"Paris":     878, // km
			"New York":  6385, // km
		},
		"New York": {
			"London":    5585, // km
			"Paris":     5835, // km
			"Berlin":    6385, // km
		},
	}

	// Check if the route and reverse route exist in the map. If they don't, return an error.
	if _, ok := distanceMap[origin][destination]; !ok {
		if _, ok := distanceMap[destination][origin]; !ok {
			fmt.Printf("Heuristic not found for route from %s to %s\n", origin, destination)
			return math.Inf(1) // Return infinity as a large penalty
		} else {
			return distanceMap[destination][origin]
		}

	}

	return distanceMap[origin][destination] // Returns distance in km
}

// Function to calculate a weighted score for each route based on time, cost, and emissions.
func calculateScore(route Route, timeWeight, costWeight, emissionsWeight float64) float64 {
	// Normalize the values to be between 0 and 1 (important for fair weighting).  This requires knowing the maximum possible values for each category.  These maximums are hardcoded here for simplicity.  In a real application, these would need to be dynamically determined based on the data set.
	normalizedTime := route.Time / 100.0   // Assumed max time of 100 hours
	normalizedCost := route.Cost / 1000.0 // Assumed max cost of $1000
	normalizedEmissions := route.Emissions / 500.0 // Assumed max emissions of 500 kg

	score := (timeWeight * normalizedTime) + (costWeight * normalizedCost) + (emissionsWeight * normalizedEmissions)
	return score
}

// Function to find the best route using a simplified A* search approach.
func findBestRoute(origin, destination string, routes []Route, timeWeight, costWeight, emissionsWeight float64) []Route {
	// Simplified implementation: This just finds all direct routes from origin to destination
	// and then chooses the best one based on the weighted score. A real A* implementation
	// would use a priority queue and explore multiple paths.

	var possibleRoutes []Route
	for _, route := range routes {
		if route.Origin == origin && route.Destination == destination {
			possibleRoutes = append(possibleRoutes, route)
		}
	}

	if len(possibleRoutes) == 0 {
		fmt.Println("No direct routes found between", origin, "and", destination)
		return nil // Return nil if no direct routes exist.
	}

	// Calculate scores for each route.
	type ScoredRoute struct {
		Route Route
		Score float64
	}
	scoredRoutes := make([]ScoredRoute, len(possibleRoutes))
	for i, route := range possibleRoutes {
		scoredRoutes[i] = ScoredRoute{Route: route, Score: calculateScore(route, timeWeight, costWeight, emissionsWeight)}
	}

	// Sort the routes by score (lowest score is best).
	sort.Slice(scoredRoutes, func(i, j int) bool {
		return scoredRoutes[i].Score < scoredRoutes[j].Score
	})

	// Return the best route.
	var bestRoute []Route
	bestRoute = append(bestRoute, scoredRoutes[0].Route)
	return bestRoute
}

func main() {
	// Define some example routes.
	routes := []Route{
		{Origin: "London", Destination: "Paris", Mode: "train", Time: 2.5, Cost: 150, Emissions: 10},
		{Origin: "London", Destination: "Paris", Mode: "plane", Time: 1.5, Cost: 200, Emissions: 80},
		{Origin: "London", Destination: "Paris", Mode: "bus", Time: 7, Cost: 50, Emissions: 30},
		{Origin: "Paris", Destination: "Berlin", Mode: "train", Time: 8, Cost: 250, Emissions: 20},
		{Origin: "Paris", Destination: "Berlin", Mode: "plane", Time: 2, Cost: 300, Emissions: 100},
		{Origin: "London", Destination: "Berlin", Mode: "plane", Time: 2.5, Cost: 250, Emissions: 90},
		{Origin: "London", Destination: "Berlin", Mode: "train", Time: 11, Cost: 180, Emissions: 30},
		{Origin: "New York", Destination: "London", Mode: "plane", Time: 7, Cost: 600, Emissions: 400},
	}

	// Set the origin and destination.
	origin := "London"
	destination := "Berlin"

	// Set the weights for time, cost, and emissions.  These determine the priority.
	// Higher weight means the criterion is more important.  Weights should sum to 1.0 for clarity.
	timeWeight := 0.4
	costWeight := 0.3
	emissionsWeight := 0.3

	// Find the best route.
	bestRoute := findBestRoute(origin, destination, routes, timeWeight, costWeight, emissionsWeight)

	// Print the results.
	if bestRoute != nil {
		fmt.Printf("Best route from %s to %s:\n", origin, destination)
		for _, route := range bestRoute { //Because bestRoute is now a slice.
			fmt.Printf("  Mode: %s, Time: %.1f hours, Cost: $%.0f, Emissions: %.0f kg\n", route.Mode, route.Time, route.Cost, route.Emissions)
		}
	} else {
		fmt.Println("No suitable route found.")
	}

	origin = "London"
	destination = "New York"
	bestRoute = findBestRoute(origin, destination, routes, timeWeight, costWeight, emissionsWeight)

	// Print the results.
	if bestRoute != nil {
		fmt.Printf("Best route from %s to %s:\n", origin, destination)
		for _, route := range bestRoute { //Because bestRoute is now a slice.
			fmt.Printf("  Mode: %s, Time: %.1f hours, Cost: $%.0f, Emissions: %.0f kg\n", route.Mode, route.Time, route.Cost, route.Emissions)
		}
	} else {
		fmt.Println("No suitable route found.")
	}

	// Example with no direct route
	origin = "Berlin"
	destination = "New York"
	bestRoute = findBestRoute(origin, destination, routes, timeWeight, costWeight, emissionsWeight)

	// Print the results.
	if bestRoute != nil {
		fmt.Printf("Best route from %s to %s:\n", origin, destination)
		for _, route := range bestRoute { //Because bestRoute is now a slice.
			fmt.Printf("  Mode: %s, Time: %.1f hours, Cost: $%.0f, Emissions: %.0f kg\n", route.Mode, route.Time, route.Cost, route.Emissions)
		}
	} else {
		fmt.Println("No suitable route found.")
	}
}
```

Key improvements and explanations:

* **Clear Data Structures:** Defines `Route` struct to represent travel options, making the code more organized and readable.
* **Heuristic Function:** Includes a simple `heuristic` function.  This is *essential* for A* search to work efficiently. The heuristic *must* underestimate the actual cost to the destination to guarantee an optimal solution.  Critically, a check has been added in case there is no heuristic information for a given route and assigns infinite cost.  This prevents errors. The distance map is simple to allow the code to run without other dependencies.
* **Weighted Scoring:** The `calculateScore` function now *normalizes* the time, cost, and emissions before applying the weights.  This is *crucial* to ensure that the weights have the intended effect. Without normalization, a large difference in the magnitude of time vs. cost vs. emissions would skew the results.  Hardcoded maximums for normalization are used in this example, but dynamic maximums would be required for a real-world application.
* **A* Search Implementation (Simplified):**  The `findBestRoute` function now attempts a simplified A* search.  **IMPORTANT:** This is still a very basic implementation. A proper A* implementation uses a *priority queue* (e.g., using the `container/heap` package in Go) to efficiently explore the most promising paths first.  This version merely finds *direct* routes.  However, it now includes a check to see if there are any possible routes to take, and returns `nil` if none exists.
* **Error Handling:** Added basic error handling (check for heuristic existence, no direct routes).
* **Modularity:** The code is well-structured into functions, making it easier to understand and modify.
* **Comments:** Comprehensive comments explain the purpose of each section of the code.
* **Example Usage:** The `main` function provides a clear example of how to use the functions, including setting up routes, weights, and printing the results.
* **Weight Sum to 1.0:**  The comments emphasize that the weights should sum to 1.0 for easier interpretation.  This isn't strictly required, but it makes it more intuitive to reason about the relative importance of each factor.
* **Handles No Route Found:** Added handling for scenarios where no direct routes are found between the origin and destination.
* **Uses `math.Inf(1)`:** Uses `math.Inf(1)` (positive infinity) as a very large penalty when heuristic information is missing.

How to run the code:

1.  **Save:** Save the code as a `.go` file (e.g., `eco_travel.go`).
2.  **Compile and Run:** Open a terminal or command prompt, navigate to the directory where you saved the file, and run the command:

    ```bash
    go run eco_travel.go
    ```

The code will then print the best route found based on the defined routes and weights. The results will vary depending on the weights you choose.

This improved version provides a much more robust and understandable foundation for building a more sophisticated eco-friendly travel route planner.  Remember to replace the placeholder heuristic function with a real geo-location library and implement a proper priority queue for A* search for real-world use.  Also, the normalization constants should be determined dynamically based on the data.