This agent can analyze competitor data, respond to inquiries, and deliver practical insights
by combining reasoning with actions.
"""

def __init__(self):
    """Initialize the Competitive Analysis Agent with necessary components."""
    self.query_history = []  # Store query history
    self.index = self._create_or_load_index()
    self.query_engine = self.index.as_query_engine(llm=llm, similarity_top_k=3)
    
    # Create tools for the agent
    self.competitor_tool = QueryEngineTool.from_defaults(
        query_engine=self.query_engine,
        name="competitor_data_tool",
        description="Provides information about competitors including product descriptions, marketing strategies, financial summaries, strengths, and weaknesses."
    )
    logger.info("Competitive tool initialized successfully")
    self.analysis_tool = FunctionTool.from_defaults(
        fn=self.analyze_competitors,
        name="competitor_analysis_tool",
        description="Analyzes and compares competitors based on specific criteria."
    )
    logger.info("Analysis tool initialized successfully")
    
    # Create ReActAgent with tools
    self.agent = ReActAgent(
        tools=[self.competitor_tool, self.analysis_tool],
        llm=llm
    )
    self.ctx = Context(workflow=self.agent)
    
    logger.info(msg="Competitive Analysis Agent initialized successfully")

def _create_or_load_index(self):
    """Create or load the vector index for competitor data."""
    index_storage_path = Path(INDEX_STORAGE_DIR)
    
    if index_storage_path.exists():
        logger.info("Loading existing index from disk...")
        storage_context = StorageContext.from_defaults(persist_dir=INDEX_STORAGE_DIR)
        index = load_index_from_storage(storage_context=storage_context, embed_model=embed_model)
    else:
        logger.info("Creating new index for competitor data...")
        # Load and preprocess competitor data
        try:
            competitors_df = pd.read_csv("competitor_data.csv")
            logger.info(f"Loaded competitor data with {len(competitors_df)} entries")
            
            # Convert DataFrame to list of Documents for indexing
            documents = []
            for _, row in competitors_df.iterrows():
                # Create a text representation of each competitor
                text = (
                    f"Competitor: {row['Competitor Name']}\n"
                    f"Product Description: {row['Product Description']}\n"
                    f"Marketing Strategy: {row['Marketing Strategy']}\n"
                    f"Financial Summary: {row['Financial Summary']}\n"
                    f"Strengths: {row['Strengths']}\n"
                    f"Weaknesses: {row['Weaknesses']}\n"
                )
                documents.append(Document(text=text))
            
            # Create index with sentence splitter for better chunking
            splitter = SentenceSplitter(chunk_size=512, chunk_overlap=50)
            
            # Create index with sentence splitter for better chunking
            index = VectorStoreIndex.from_documents(
                documents,
                embed_model=embed_model,
                transformations=[splitter]
            )
            
            # Persist index to disk
            os.makedirs(INDEX_STORAGE_DIR, exist_ok=True)
            index.storage_context.persist(persist_dir=INDEX_STORAGE_DIR)
            logger.info("Index created and saved to disk")
            
        except Exception as e:
            logger.error(f"Error creating index: {e}")
            raise
            
    return index

def analyze_competitors(self, aspect: str, competitors: str = "") -> str:
    """
    Analyze competitors based on specific aspects.
    
    Args:
        aspect: The aspect to analyze (e.g., 'marketing', 'financial', 'strengths')
        competitors: Comma-separated list of competitor names (optional)
        
    Returns:
        str: Analysis results
    """
    try:
        df = pd.read_csv("competitor_data.csv")
        
        if competitors:
            competitor_list = [c.strip() for c in competitors.split(',')]
            df = df[df['Competitor Name'].isin(competitor_list)]
        
        result_parts = []
        
        if aspect.lower() == 'marketing':
            for i in range(len(df)):
                result_parts.append(f"{df.iloc[i]['Competitor Name']}: {df.iloc[i]['Marketing Strategy']}")
            result = "\n".join(result_parts)
        elif aspect.lower() == 'financial':
            for i in range(len(df)):
                result_parts.append(f"{df.iloc[i]['Competitor Name']}: {df.iloc[i]['Financial Summary']}")
            result = "\n".join(result_parts)
        elif aspect.lower() == 'strengths':
            for i in range(len(df)):
                result_parts.append(f"{df.iloc[i]['Competitor Name']}: {df.iloc[i]['Strengths']}")
            result = "\n".join(result_parts)
        elif aspect.lower() == 'weaknesses':
            for i in range(len(df)):
                result_parts.append(f"{df.iloc[i]['Competitor Name']}: {df.iloc[i]['Weaknesses']}")
            result = "\n".join(result_parts)
        elif aspect.lower() == 'products':
            for i in range(len(df)):
                result_parts.append(f"{df.iloc[i]['Competitor Name']}: {df.iloc[i]['Product Description']}")
            result = "\n".join(result_parts)
        else:
            result = "Aspect not recognized. Available aspects: marketing, financial, strengths, weaknesses, products"
            
        return result
        
    except Exception as e:
        logger.error(f"Error in competitor analysis: {e}")
        return f"Error analyzing competitors: {str(e)}"

def reason_and_act(self, query: str) -> str:
    """
    Process a query using ReAct agent with Cohere.
    """
    logger.info(f"Processing query: {query}")

    try:
        # Use the ReAct agent to process the query
        print(f"\nProcessing query with Cohere ReAct agent: {query}")
        
        # Create a new context for this query
        import asyncio
        
        # Run the agent asynchronously
        async def run_agent():
            handler = self.agent.run(query, ctx=self.ctx)
            print(f"\n waiting for stream events")
            # Stream and process events in real-time
            #async for event in handler.stream_events(True):
            #        if isinstance(event, StopEvent):
            #            print(f"Workflow completed with result: {event.result}")
            #        else:
            #            print(f"Received event: {event}")
            response = await handler
            return response
            
        # Execute the async function
        response = asyncio.run(run_agent())
        
        # Save to history and return
        self.query_history.append((query, str(response)))
        logger.info("Returning the response")
        return str(response)

    except Exception as e:
        error_msg = f"Error processing query: {str(e)}"
        logger.error(error_msg)
        import traceback
        traceback.print_exc()
        
        # Fallback to direct query engine if agent fails
        try:
            print(f"\nFalling back to direct query engine: {query}")
            response = self.query_engine.query(query)
            return str(response)
        except Exception as e2:
            return f"Error processing query: {str(e)}\nFallback error: {str(e2)}"


def get_query_history(self, limit: int = 5) -> list:
    """
    Get recent query history.
    
    Args:
        limit: Maximum number of recent queries to return
        
    Returns:
        list: List of (query, response) tuples
    """
    return self.query_history[-limit:] if self.query_history else []

try:
    # Initialize the agent
    agent = CompetitiveAnalysisAgent()
    
    while True:
        user_query = input("\nEnter your query: ").strip()
        
        if user_query.lower() == 'exit':
            print("Thank you for using the Competitive Analysis Agent. Goodbye!")
            break
            
        if user_query.lower() == 'history':
            history = agent.get_query_history()
            if history:
                print("\nRecent Queries:")
                for i, (q, r) in enumerate(history, 1):
                    print(f"{i}. Query: {q}")
                    print(f"   Response: {r[:100]}..." if len(r) > 100 else f"   Response: {r}")
                    print()
            else:
                print("No query history yet.")
            continue
            
        if not user_query:
            print("Please enter a valid query.")
            continue
            
        print("\nProcessing your query...")
        response = agent.reason_and_act(user_query)
        print(f"\nResponse: {response}")
        
except Exception as e:
    logger.error(f"Application error: {e}")
    print(f"An error occurred: {e}")
    import traceback
    traceback.print_exc()