import os, json, random, io, logging

from pulp import *

from helpers import aws_helper, tar_helper, csv_helper, service_helper, irt_helper

from models.solver_run import SolverRun
from models.solution import Solution
from models.form import Form

from services.base import Base

class LoftService(Base):
  def process(self):
    self.solver_run = SolverRun.parse_obj(self.retreive_attributes_from_message())
    self.solution = self.generate_solution()
    self.result = self.stream_to_s3_bucket()

  def retreive_attributes_from_message(self):
    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())

    # 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 attributes dict
    attributes['items'] = service_helper.items_csv_to_dict(items_csv_reader)
    logging.info('Processed Attributes...')

    return attributes

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

    # counter for number of forms
    f = 0

    # iterate for number of forms that require creation
    # currently creates distinc forms with no item overlap
    while f < self.solver_run.total_forms:
      # setup vars
      items = LpVariable.dicts(
        "Item", [item.id for item in self.solver_run.items], lowBound=1, upBound=1, cat='Binary')
      used = dict(zip([item.id for item in self.solver_run.items],
                  [1 for item in self.solver_run.items]))
      problem_objection_functions = []

      # create problem
      problem = LpProblem("ata-form-generate", LpMinimize)

      # constraints
      problem += lpSum([items[item.id]
                    for item in self.solver_run.items]) == self.solver_run.total_form_items, 'Total form items'

      for constraint in self.solver_run.constraints:
        con = dict(zip([item.id for item in self.solver_run.items], 
                       [item.attribute_exists(constraint.reference_attribute.id, constraint.reference_attribute.value)
                       for item in self.solver_run.items]))
        problem += lpSum([con[item.id]
                         * items[item.id]
                         for item in self.solver_run.items]) >= round(self.solver_run.total_form_items * (constraint.minimum / 100)), f'{constraint.reference_attribute.id} - {constraint.reference_attribute.value} - min'
        problem += lpSum([con[item.id]
                         * items[item.id]
                         for item in self.solver_run.items]) <= round(self.solver_run.total_form_items * (constraint.maximum / 100)), f'{constraint.reference_attribute.id} - {constraint.reference_attribute.value} - max'

      # multi-objective functions and constraints
      for target in self.solver_run.objective_function.tif_targets:
          tif = lpSum([item.iif(self.solver_run, target.theta)*items[item.id]
                      for item in self.solver_run.items])
          problem += lpSum([item.iif(self.solver_run, target.theta)*items[item.id]
                         for item in self.solver_run.items]) <= target.value, f'min tif theta ({target.theta}) target value {target.value}'
          problem_objection_functions.append(tif)

      for target in self.solver_run.objective_function.tcc_targets:
          tcc = lpSum([item.irf(self.solver_run, target.theta)*items[item.id]
                      for item in self.solver_run.items])
          problem += lpSum([item.irf(self.solver_run, target.theta)*items[item.id]
                         for item in self.solver_run.items]) <= target.value, f'min tcc theta ({target.theta}) target value {target.value}'
          problem_objection_functions.append(tcc)

      # solve problem
      problem.sequentialSolve(problem_objection_functions)

      # add return items and create as a form
      form_items = []
      for v in problem.variables():
        count = 0
        if v.varValue > 0:
          item_id = v.name.replace('Item_', '')
          for item in self.solver_run.items:
            if str(item.id) == item_id:
              # add item to list
              form_items.append(item)
              # remove ids from master items list
              self.solver_run.items.remove(item)

      # add form to solution
      solution.forms.append(Form.create(form_items, self.solver_run))

      # successfull form, increment
      f += 1

    return solution

  def stream_to_s3_bucket(self):
    self.file_name = f'{service_helper.key_to_uuid(self.key)}.csv'
    logging.info('Streaming %s to s3 bucket - %s', self.file_name, os.environ['S3_PROCESSED_BUCKET'])
    # setup writer buffer and write processed forms to file
    buffer = io.StringIO()
    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, os.environ['S3_PROCESSED_BUCKET'])