import gradio as gr
import json

from smolagents import CodeAgent, tool, Tool, FinalAnswerTool, HfApiModel, load_tool

final_answer = FinalAnswerTool()
model = HfApiModel()

class ProjectScopingTool(Tool):
    name = "project_scoping_tool"
    description = """
    Handles project scoping by collecting key details such as type, domain, budget, and timeline.
    """

    inputs = {

        "project_type": {
            "type": "string",

            "description": "The type of project (e.g., 'web', 'blockchain', 'ai').",
        },
        "domain": {
            "type": "string"
,
            "description": "The industry or field related to the project (e.g., 'finance', 'healthcare').",
        },
        "budget_min": {
            "type": "number",
            "description": "The minimum budget allocated for the project."
,
        },
        "budget_max": {
            "type": "number",
            "description": "The maximum budget allocated for the project.",
        },
        "timeline_months": {
            "type": "number",
            "description": "The expected duration of the project in months.",
        },

    }

    output_type = "object"

    def forward(self, project_type: str, domain: str, budget_min: float, budget_max: float, timeline_months: int):
        project_details = {
            "type": project_type,
            "domain": domain,
            "budget_range": {"min": budget_min, "max": budget_max},
            "timeline": {"months": timeline_months}
        }
        return json.dumps(project_details, indent=2)

class TechnicalArchitectureTool(Tool):
    name = "technical_architecture_tool"
    description = """
    Determines the appropriate technical architecture based on the project type.
    """

    inputs = {
        "project_type": {
            "type": "string",
            "description": "The type of project (e.g., 'web', 'blockchain', 'ai').",
        }
    }

    output_type = "object"

    def forward(self, project_type: str):
        architectures = {
            "web": {
                "frontend": ["React", "Next.js", "Tailwind"],
                "backend": ["FastAPI", "Django", "Express"],
                "database": ["PostgreSQL", "MongoDB"]
            },
            "blockchain": {
                "blockchain_type": "EVM-compatible",
                "smart_contract_language": "Solidity",
                "consensus_mechanism": "Proof of Stake"
            },
            "ai": {
                "model_type": "Transformer",
                "inference_strategy": "Cloud-based",
                "data_processing": "Distributed"
            }
        }
        return json.dumps(architectures.get(project_type, "Invalid project type"), indent=2)

class CostEstimationTool(Tool):
    name = "cost_estimation_tool"
    description = """
    Estimates the cost based on the architecture complexity and timeline.
    """

    inputs = {
        "architecture_size": {
            "type": "number",
            "description": "The estimated complexity of the architecture on a scale from 1 to 10.",
        },
        "timeline_months": {
            "type": "number",
            "description": "The project duration in months.",
        }
    }

    output_type = "object"

    def forward(self, architecture_size: int, timeline_months: int):
        base_costs = {
            "development": 5000 * (architecture_size * 0.5),
            "infrastructure": 500 * (architecture_size * 0.3),
            "maintenance": 1000 * (architecture_size * 0.2)
        }
        total_cost = sum(base_costs.values())
        return json.dumps({"total_estimated_cost": total_cost, "breakdown": base_costs}, indent=2)

class DeploymentTool(Tool):
    name = "deployment_tool"
    description = """
    Suggests a deployment strategy based on best practices.
    """

    inputs = {}

    output_type = "object"

    def forward(self):
        return json.dumps({
            "container_strategy": "Docker + Kubernetes",
            "cloud_provider": "AWS",
            "services": ["ECS", "Lambda", "S3", "RDS"],
            "ci_cd_pipeline": "GitHub Actions"
        }, indent=2)

class MeetingPreparationTool(Tool):
    name = "meeting_preparation_tool"
    description = """
    Provides meeting agendas depending on the project stage.
    """

    inputs = {
        "project_stage": {
            "type": "string",
            "description": "The current stage of the project (e.g., 'initial_discovery', 'architecture_review').",
        }
    }

    output_type = "object"

    def forward(self, project_stage: str):
        agendas = {
            "initial_discovery": [
                "Project Vision Validation",
                "Technical Feasibility Discussion",
                "Initial Scope Definition"
            ],
            "architecture_review": [
                "Technical Architecture Walkthrough",
                "Technology Stack Validation",
                "Performance Considerations"
            ]
        }
        return json.dumps(agendas.get(project_stage, "No agenda found for this stage"), indent=2)


project_scoping_tool =  ProjectScopingTool()
technical_architecture_tool = TechnicalArchitectureTool()
cost_estimation_tool = CostEstimationTool()
deployment_tool = DeploymentTool()
meeting_preparation_tool = MeetingPreparationTool()
# Instantiate tools
tools = [
    project_scoping_tool,
    technical_architecture_tool,
    cost_estimation_tool,
    deployment_tool,
    meeting_preparation_tool,
    final_answer
]

# Define the agent
agent = CodeAgent(
    model=model,
    tools=tools,  # Fixed tools list format
    max_steps=6,
    verbosity_level=1,
    name="webchainai",
    description="Sets up first project mockups"
)

# Define Gradio Interface
with gr.Blocks() as demo:
    gr.Markdown("# 🏗️ Project Scoping & Cost Estimation Tool")

    with gr.Row():
        project_type = gr.Dropdown(["web", "blockchain", "ai"], label="Select Project Type")
        domain = gr.Textbox(label="Enter Project Domain")

    with gr.Row():
        budget_min = gr.Number(label="Min Budget ($)")
        budget_max = gr.Number(label="Max Budget ($)")
        timeline_months = gr.Number(label="Timeline (Months)")

    project_output = gr.Textbox(label="Project Details", interactive=False)
    arch_output = gr.Textbox(label="Technical Architecture", interactive=False)
    cost_output = gr.Textbox(label="Estimated Cost", interactive=False)
    deploy_output = gr.Textbox(label="Deployment Strategy", interactive=False)
    meeting_output = gr.Textbox(label="Meeting Agenda", interactive=False)

    def process_inputs(p_type, dom, min_b, max_b, months):
        project_details = tools[0].forward(p_type, dom, min_b, max_b, months)
        architecture = tools[1].forward(p_type)
        estimated_cost = tools[2].forward(5, months)  # Example architecture size
        deployment_strategy = tools[3].forward()
        meeting_agenda = tools[4].forward("initial_discovery")
        return project_details, architecture, estimated_cost, deployment_strategy, meeting_agenda

    process_button = gr.Button("Generate Estimates")
    process_button.click(process_inputs, inputs=[project_type, domain, budget_min, budget_max, timeline_months], 
                         outputs=[project_output, arch_output, cost_output, deploy_output, meeting_output])

# Launch the Gradio App
demo().launch()
#agent.run("Ask user what they want to do")