from typing import Any, Dict, List
import random
from common.base_problem import BaseProblem
from problems.flower_planting.generator import generate_flower_planting_case
from problems.flower_planting.solvers import solve_greedy, solve_brute_force, max_flowers_greedy
from common.timer_utils import time_execution

class FlowerPlantingProblem(BaseProblem):
    def generate_case(self, length: int = 10, n: int = 0) -> Dict[str, Any]:
        flowerbed = generate_flower_planting_case(length)
        # If n is not provided (or 0), generate a challenging but possible n
        # We calculate max possible, then take a random portion of it or just use it.
        # Let's just return the bed and let user/frontend specify n, OR generate a random N.
        # Problem requires checking if n can be planted.
        if n == 0:
             max_possible = max_flowers_greedy(flowerbed)
             # Randomly pick n between 0 and max_possible + 1 (to sometimes return False)
             n = random.randint(0, max_possible + 1) if max_possible > 0 else 1

        return {"flowerbed": flowerbed, "n": n}

    def solve(self, input_data: Dict[str, Any], algorithm: str) -> Dict[str, Any]:
        flowerbed = input_data.get("flowerbed", [])
        n = input_data.get("n", 1)
        
        result = None
        duration = 0.0

        if algorithm == "greedy":
            result, duration = time_execution(solve_greedy)(flowerbed, n)
        elif algorithm == "brute_force":
            result, duration = time_execution(solve_brute_force)(flowerbed, n)
        else:
            raise ValueError(f"Unknown algorithm: {algorithm}")
        
        return {
            "algorithm": algorithm,
            "can_plant": result,
            "time_seconds": duration
        }

    def verify(self, input_data: Any, result: Any) -> bool:
        flowerbed = input_data.get("flowerbed", [])
        n = input_data.get("n", 1)
        truth, _ = time_execution(solve_greedy)(flowerbed, n)
        return result.get("can_plant") == truth