import os
import sys
import json
import re

# ✅ Step 1: Check if `requests` is installed
try:
    import requests
except ImportError:
    print("\n⚠️ `requests` module not found! Checking internet connection...\n")

    # Check internet connection using a simple ping
    def check_connection():
        try:
            os.system("ping -c 1 bing.com >nul 2>&1")  # Linux/macOS
            os.system("ping -n 1 bing.com >nul 2>&1")  # Windows
            return True
        except Exception:
            return False

    online = check_connection()

    if online:
        print("\n🌐 Internet detected! Installing `requests`...\n")
        os.system("pip install requests")
        try:
            import requests
            print("\n✅ `requests` installed successfully!\n")
        except ImportError:
            print("\n🚨 Installation failed! Please install manually: `pip install requests`\n")
            sys.exit(1)
    else:
        print("\n🚨 No internet detected! 🚨 Running in offline mode...\n")

        # Create a fake requests module to avoid crashes
        class FakeRequests:
            def get(self, url):
                return None
        requests = FakeRequests()

# ✅ Step 2: CGG-EUSO Chatbot
class CGG_EUSO:
    def __init__(self):
        self.knowledge_file = "knowledge.json"
        self.responses_file = "responses.json"
        self.load_data()

    def load_data(self):
        """Loads stored knowledge and responses from files."""
        try:
            with open(self.knowledge_file, "r", encoding="utf-8") as f:
                self.knowledge = json.load(f)
        except FileNotFoundError:
            self.knowledge = {}

        try:
            with open(self.responses_file, "r", encoding="utf-8") as f:
                self.responses = json.load(f)
        except FileNotFoundError:
            self.responses = {}

    def save_data(self):
        """Saves learned knowledge and responses to files."""
        with open(self.knowledge_file, "w", encoding="utf-8") as f:
            json.dump(self.knowledge, f, ensure_ascii=False, indent=4)
        with open(self.responses_file, "w", encoding="utf-8") as f:
            json.dump(self.responses, f, ensure_ascii=False, indent=4)

    def check_online(self):
        """Checks if the computer is online."""
        try:
            requests.get("http://www.bing.com", timeout=5)
            return True
        except:
            return False

    def analyze_knowledge(self, text):
        """Analyzes and refines online knowledge before saving."""
        text = re.sub(r'\s+', ' ', text)  # Remove unnecessary spaces
        text = re.sub(r'<.*?>', '', text)  # Remove HTML tags (if any)
        text = text.strip()
        if len(text) > 300:  # If too long, summarize it
            text = text[:300] + "..."
        return text

    def search_online(self, query):
        """Searches Bing if knowledge is missing and analyzes the result."""
        if not self.check_online():
            return "I am offline and cannot search right now."

        print("\n🌍 Searching online on Bing...\n")
        try:
            response = requests.get(f"https://www.bing.com/search?q={query}", timeout=5)
            raw_text = response.text
            processed_text = self.analyze_knowledge(raw_text)
            result = f"Online result: {processed_text}"
            self.learn_knowledge(query, processed_text)  # 🔥 Save the refined result
            return result
        except Exception:
            return "Failed to retrieve online information."

    def learn_knowledge(self, topic, info):
        """Adds new knowledge after analyzing it."""
        if topic not in self.knowledge:
            self.knowledge[topic] = info
            self.save_data()

    def learn_response(self, question, answer):
        """Learns how to respond to the user."""
        if question not in self.responses:
            self.responses[question] = answer
            self.save_data()

    def respond(self, user_input):
        """Generates a response based on learned knowledge."""
        if user_input in self.responses:
            return self.responses[user_input]

        if user_input in self.knowledge:
            return f"Here's what I know: {self.knowledge[user_input]}"

        # 🔥 Auto-search online if it doesn’t know the answer
        if self.check_online():
            return self.search_online(user_input)
        else:
            print("\n🤔 I don't know this yet. Please teach me!")
            new_response = input("Enter a response: ")
            self.learn_response(user_input, new_response)
            return "Got it! I'll remember this."

    def show_code(self):
        """Displays the AI’s modified code, showing stored knowledge & responses."""
        print("\n📜 **CGG-EUSO Code Check Mode** 📜")
        print("\nKnowledge stored:")
        print(json.dumps(self.knowledge, ensure_ascii=False, indent=4))
        print("\nResponses stored:")
        print(json.dumps(self.responses, ensure_ascii=False, indent=4))

# ✅ Step 3: Run the Chatbot
bot = CGG_EUSO()

print("\n💬 CGG-EUSO is ready! Choose a mode:")
print("1️⃣ Chat Mode")
print("2️⃣ Code Check Mode")

while True:
    mode = input("\nSelect (1/2): ").strip()
    if mode == "1":
        print("\n💬 Enter 'exit' to quit.\n")
        while True:
            user_input = input("You: ")
            if user_input.lower() == "exit":
                print("\nGoodbye! 👋")
                break
            response = bot.respond(user_input)
            print(f"CGG-EUSO: {response}")
        break
    elif mode == "2":
        bot.show_code()
        break
    else:
        print("\n❌ Invalid choice! Please enter '1' or '2'.")