import requests
import os, shutil, subprocess
from dotenv import load_dotenv
import zipfile
import json
from PIL import Image
from math import floor
from Helpers import capture_message
import urllib3

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)


class Service:
    def __init__(self, orderId, hash, isApp):
        load_dotenv()

        self.isApp = isApp
        self.service_endpoint = os.getenv('SERVICE_ENDPOINT')
        self.app_dir = os.getenv('APP_DIR')
        self.instance_dir = os.getenv('INSTANCE_DIR')
        self.output_images = os.getenv('OUTPUT_IMAGES')
        self.output_dir = os.getenv('OUTPUT_DIR')
        self.archive_filename = self.app_dir + 'instance.zip'
        self.archive_output_images = self.app_dir + 'output_images.zip'

        self.headers = {
            'Authorization': hash,
        }

        self.params = {
            'orderId': orderId,
        }

    # Download images
    def download(self):
        self.scarify()

        # Get images
        try:
            response = requests.post(self.service_endpoint + 'download',
                                     headers=self.headers,
                                     json=self.params,
                                     verify=False)
        except requests.exceptions.RequestException as e:
            capture_message('Failed: Service download')
            return False

        if response.status_code != 200:
            capture_message("Failed: Service download")
            return False

        with open(self.archive_filename, 'wb') as f:
            f.write(response.content)

        capture_message("Downloaded images")

        # Extract
        capture_message("Extract zip")
        with zipfile.ZipFile(self.archive_filename, "r") as zip_ref:
            zip_ref.extractall(self.instance_dir)
        capture_message("Extracted zip")

        subprocess.run(['chmod', '-R', '777', self.instance_dir], cwd='/repository')

        # Resize Image
        capture_message("Resize Image")

        for item in os.listdir(self.instance_dir):
            try:
                size = 512
                image = Image.open(self.instance_dir + item)

                if image.mode in ("RGBA", "P"): image = image.convert("RGB")

                width, height = image.size

                if width == height:
                    image = image.resize((size, size), Image.ANTIALIAS)

                if height < width:
                    ratio = float(width) / float(height)
                    new_width = ratio * size
                    image = image.resize((int(floor(new_width)), size), Image.ANTIALIAS)

                if width < height:
                    ratio = float(height) / float(width)
                    new_height = ratio * size
                    image = image.resize((size, int(floor(new_height))), Image.ANTIALIAS)

                width, height = image.size
                image = image.crop(((width - size) / 2, (height - size) / 2, (width + size) / 2, (height + size) / 2))
                image.save(self.instance_dir + item, "JPEG")
            except:
                capture_message("Resize Image" + item)

        capture_message("Resized Image")
        return True

    # Get data
    def data(self):
        try:
            response = requests.post(self.service_endpoint + 'data',
                                     headers=self.headers,
                                     json=self.params,
                                     verify=False)
        except requests.exceptions.RequestException as e:
            capture_message('Failed: Service data')
            return False

        if response.status_code != 200:
            return False

        capture_message('Data received.')
        return response.json()

    def restart(self):
        try:
            response = requests.post(self.service_endpoint + 'restart',
                                     headers=self.headers,
                                     json=self.params,
                                     verify=False)
        except requests.exceptions.RequestException as e:
            capture_message('Failed: Restart')
            return False

        if response.status_code != 200:
            capture_message('Failed: Restart')
            return False

        capture_message('Restarted')

    def finish(self):
        shutil.make_archive(self.app_dir + 'output_images', 'zip', self.output_images)

        headers = self.headers
        headers['Accept'] = 'application/json'

        files = {'generated': open(self.archive_output_images, 'rb')}
        endpoint = self.service_endpoint + 'finish'
        if int(self.isApp) == 1:
            endpoint = self.service_endpoint + 'app/finish'

        try:
            requests.post(endpoint,
                          headers=headers,
                          data=self.params,
                          files=files,
                          verify=False
                          )
        except requests.exceptions.RequestException as e:
            capture_message('Failed: Service finish')
            return False

        capture_message('Uploaded images')

    # Remove old files
    def scarify(self):
        if os.path.exists(self.instance_dir):
            shutil.rmtree(self.instance_dir)

        if os.path.exists(self.output_dir):
            shutil.rmtree(self.output_dir)

        if not os.path.exists(self.output_dir):
            os.mkdir(self.output_dir)

        if os.path.exists(self.archive_filename):
            os.remove(self.archive_filename)

        if os.path.exists(self.output_images):
            shutil.rmtree(self.output_images)

        if not os.path.exists(self.output_images):
            os.mkdir(self.output_images)

        if os.path.exists(self.archive_output_images):
            os.remove(self.archive_output_images)