import json, random, io, logging

from pulp import LpProblem, LpVariable, LpMinimize, LpStatus, lpSum

from lib.application_configs import ApplicationConfigs
from helpers import aws_helper, tar_helper, csv_helper, service_helper
from lib.errors.item_generation_error import ItemGenerationError

from models.solver_run import SolverRun
from models.solution import Solution
from models.problem import Problem
from models.form import Form
from models.targets.target import Target

from services.base import Base

class FormGenerationService(Base):
    ACTION = 'formGeneration'

    def process(self):
        try:
            self.solver_run = self.create_solver_run_from_attributes()
            self.solver_run.generate_bundles()
            self.solution = self.generate_solution()
            self.result = self.stream_to_s3_bucket()
        except ItemGenerationError as error:
            self.result = self.stream_to_s3_bucket(error)
        except TypeError as error:
            logging.error(error)
            self.result = self.stream_to_s3_bucket(
                ItemGenerationError(
                    "Provided params causing error in calculation results"))

    def create_solver_run_from_attributes(self) -> SolverRun:
        logging.info('Retrieving attributes from message...')
        # get s3 object
        self.key = aws_helper.get_key_from_message(self.source)
        s3_object = aws_helper.get_object(
            self.key, aws_helper.get_bucket_from_message(self.source))

        # convert to tar
        self.tar = tar_helper.raw_to_tar(s3_object)

        # get attributes file and convert to dict
        attributes = json.loads(
            tar_helper.extract_file_from_tar(
                self.tar, 'solver_run_attributes.json').read())

        # create solver run
        solver_run = SolverRun.parse_obj(attributes)

        # get items file and convert to dict
        items_csv = tar_helper.extract_file_from_tar(self.tar, 'items.csv')
        items_csv_reader = csv_helper.file_stream_reader(items_csv)

        # add items to solver run
        solver_run.items = service_helper.csv_to_item(items_csv_reader,
                                                      solver_run)

        logging.info('Processed Attributes...')

        return solver_run

    def generate_solution(self) -> Solution:
        logging.info('Generating Solution...')

        solution = Solution(response_id=random.randint(100, 5000),
                            forms=[])  # unsolved solution

        # iterate for number of forms that require creation
        for form_count in range(self.solver_run.total_forms):
            form_number = form_count + 1
            current_drift = 0  # FF Tokyo Drift

            logging.info(f'Generating Solution for Form {form_number} using the {self.solver_run.irt_model.model} IRT model')

            while current_drift <= Target.max_drift():
                drift_percent = current_drift / 100
                self.solver_run.objective_function.update_targets_drift(
                    drift_percent)

                # create problem
                problem_handler = Problem(items = self.solver_run.unbundled_items(), bundles = self.solver_run.bundles, problem = LpProblem('ata-form-generate', LpMinimize))
                problem_handler.generate(solution, self.solver_run)
                problem = problem_handler.solve()

                if LpStatus[problem.status] == 'Infeasible':
                    logging.info(
                        f'attempt infeasible for drift of {current_drift}%')

                    if current_drift >= Target.max_drift(
                    ):  # this is the last attempt, so lets finalize the solution
                        if ApplicationConfigs.local_dev_env:
                            service_helper.print_problem_variables(problem)

                        logging.info(
                            f'No feasible solution found for Form {form_number}!'
                        )
                        logging.error(problem)

                        self.add_form_to_solution(problem, solution)

                        break

                    current_drift += Target.max_drift_increment()
                else:
                    if ApplicationConfigs.local_dev_env:
                        service_helper.print_problem_variables(problem)

                    logging.info(
                        f'Optimal solution found with drift of {current_drift}%!'
                    )

                    self.add_form_to_solution(problem, solution)

                    break

        logging.info('Solution Generated.')

        return solution

    def add_form_to_solution(self, problem: LpProblem, solution: Solution):
        # add return items and create as a form
        form_items, solver_variables = service_helper.solution_items(
            problem.variables(), self.solver_run)
        form = Form.create(form_items, self.solver_run,
                           LpStatus[problem.status], solver_variables)

        solution.forms.append(form)

        logging.info('Form generated and added to solution...')

    def stream_to_s3_bucket(self, error=None):
        self.file_name = f'{service_helper.key_to_uuid(self.key)}.csv'
        solution_file = None
        # setup writer buffer and write processed forms to file
        buffer = io.StringIO()

        if error:
            logging.info('Streaming %s error response to s3 bucket - %s',
                         self.file_name,
                         ApplicationConfigs.s3_processed_bucket)
            solution_file = service_helper.error_to_file(buffer, error)
        else:
            logging.info('Streaming %s to s3 bucket - %s', self.file_name,
                         ApplicationConfigs.s3_processed_bucket)
            solution_file = service_helper.solution_to_file(
                buffer, self.solver_run.total_form_items, self.solution.forms)

        # upload generated file to s3 and return result
        return aws_helper.file_stream_upload(
            solution_file, self.file_name,
            ApplicationConfigs.s3_processed_bucket, self.ACTION)