import sys
import os
from typing import Dict, Any

current_dir = os.path.dirname(os.path.abspath(__file__))
parent_dir = os.path.dirname(current_dir)
if parent_dir not in sys.path:
    sys.path.insert(0, parent_dir)

from scoring_api import evaluate
from phase2.candidate_generator import CandidateGenerator
from phase2.validation import CodeValidator
from phase2.selector import CandidateSelector

class IterativeOptimizer:

    def __init__(self, target_score: float = 15.0, max_iterations: int = 2):
        self.target_score = target_score
        self.max_iterations = max_iterations
        self.generator = CandidateGenerator()
        self.validator = CodeValidator()
        self.selector = CandidateSelector()

    def optimize(self, initial_code: str) -> Dict[str, Any]:
        initial_eval = evaluate(initial_code)
        initial_score = initial_eval.get('risk_score', 100)
        
        current_code = initial_code
        best_overall_candidate = None
        best_overall_score = initial_score
        iteration_history = []

        print(f"Initial Code Risk Score: {initial_score} (Target: <= {self.target_score})")

        if initial_score <= self.target_score:
            print("Code already satisfies target maintainability score.")
            return {
                'initial_code': initial_code,
                'final_code': initial_code,
                'initial_score': initial_score,
                'final_score': initial_score,
                'best_candidate_details': None,
                'history': [],
                'iterations_run': 0
            }

        for iteration in range(1, self.max_iterations + 1):
            print(f"\n--- Starting Optimization Iteration {iteration}/{self.max_iterations} ---")
            raw_candidates = self.generator.generate_candidates(current_code)
            valid_candidates = self.validator.filter_valid_candidates(initial_code, raw_candidates)

            if not valid_candidates:
                print("No valid candidates generated in this iteration. Halting optimization.")
                break

            best_iteration_candidate = self.selector.select_best(valid_candidates)
            if best_iteration_candidate is None:
                print("Failed to score candidates in this iteration. Halting optimization.")
                break

            current_score = best_iteration_candidate.get('risk_score', 100)
            strategy_used = best_iteration_candidate['candidate_data'].get('strategy', 'Refactor')
            print(f"Best candidate in iteration {iteration} [{strategy_used}] achieved risk score: {current_score}")
            iteration_history.append({
                'iteration': iteration,
                'best_candidate': best_iteration_candidate
            })

            if current_score < best_overall_score:
                best_overall_score = current_score
                best_overall_candidate = best_iteration_candidate
                current_code = best_iteration_candidate['candidate_data']['code']
            else:
                print("No further risk reduction in this iteration.")

            if best_overall_score <= self.target_score:
                print(f"Target score of {self.target_score} achieved! Stopping early.")
                break

        final_code = best_overall_candidate['candidate_data']['code'] if best_overall_candidate else current_code

        print("\n=== Optimization Process Complete ===")
        print(f"Initial Risk Score: {initial_score} -> Final Best Score: {best_overall_score}")

        return {
            'initial_code': initial_code,
            'final_code': final_code,
            'initial_score': initial_score,
            'final_score': best_overall_score,
            'best_candidate_details': best_overall_candidate,
            'history': iteration_history,
            'iterations_run': len(iteration_history)
        }

if __name__ == '__main__':
    try:
        sys.stdout.reconfigure(encoding='utf-8')
    except Exception:
        pass

    print('Initializing Iterative Optimizer...')
    try:
        optimizer = IterativeOptimizer(target_score=10.0, max_iterations=2)
        sample_code = '''
global_counter = 0

def bloated_pipeline(data):
    global global_counter
    try:
        for x in data:
            if x > 0:
                for i in range(x):
                    try:
                        if i % 2 == 0:
                            global_counter += 1
                    except:
                        pass
    except Exception:
        return -1
    return global_counter
'''
        print('Starting optimization on sample code...')
        result = optimizer.optimize(sample_code)
        print('\n=== Final Optimization Report ===')
        print('Initial Code:\n', result['initial_code'])
        print('\nFinal Optimized Code:\n', result['final_code'])
        print('\nTotal Iterations:', result['iterations_run'])
        print('Final Score:', result['final_score'])
    except Exception as e:
        print(f'Error during execution: {e}')