#!/usr/bin/env python
# coding: utf-8

# In[18]:
import numpy as np
from PIL import Image
import cv2
import requests
import numpy
import pprint

URL = 'https://api.arstand-lab.ru'
token = '69b8b503205c6a1ca49728f082686624d07b137d'
HEADERS = {'Authorization': 'Token ' + token}


def transform_triangle(image, start_points=[], triangle_end_points=[], size=300):
    image = image.astype('uint8')

    skip = False
    rows, cols = image.shape[:2]
    pts1 = np.float32(start_points)
    pts2 = np.float32(triangle_end_points)
    print(start_points, triangle_end_points)
    M = cv2.getAffineTransform(pts1, pts2)
    transformed_image = cv2.warpAffine(image, M, (round(size), round(size)))
    return transformed_image


def get_faces_npz():
    #res = requests.get(f'{URL}/api/0/task/get_task/pyramid_faces_morphing',
     #                  headers=HEADERS)

    #with open('file.npz', 'wb') as f:
#        f.write(res.content)
#        data = numpy.load('file.npz')

    data = numpy.load('file.npz')
    dict = {
        "projector": data['projector'],
        "side": data['side'],
        "step": data['step'],
        "ij_coords": data['ij_coords'],
        "xyz_faces": data['xyz_faces'],
        "face_img": data['face_img'],
        "img_coords": data['img_coords']
    }

    return dict


def post_faces_projections_npz(mas):
    numpy.savez('file1.npz', answer=mas)

    files = {'answer': open('file1.npz', 'rb')}
    res = requests.post(f'{URL}/api/0/task/check_task/pyramid_faces_morphing',
                        headers=HEADERS, files=files)
    if res.ok:
        print(res.content)
        return True
    else:
        print(res.content)
        return False


def projection_coordinates(projector, side, step, ij_coords, xyz_faces, face_img, img_coords):
    ij_coords = ij_coords.tolist()
    xyz_faces = xyz_faces.tolist()
    side = side.tolist()
    xp, yp, zp = projector
    images = []
    for figure in xyz_faces:
        figure_number = xyz_faces.index(figure)
        cell_coordinate = [ij_coords[figure_number][0] * step, ij_coords[figure_number][1] * step]
        i = 0
        size = [300, 300]
        combined = None
        for polygon in figure:
            side_projection = []
            for coordinates in polygon:
                xv, yv, zv = coordinates
                xv = cell_coordinate[0] + side / 2 + xv
                yv = cell_coordinate[1] + side / 2 + yv
                coefficient = - zp / (zv - zp)
                xt = (coefficient*(xv - xp) + xp) - cell_coordinate[0]
                yt = (coefficient*(yv - yp) + yp) - cell_coordinate[1]
                zt = 0
                xt = 300 * xt / side
                yt = 300 * yt / side
                projection_point = [xt, yt]
                print(projection_point)
                side_projection.append(projection_point)
            polygon_number = [xyz_faces.index(figure), figure.index(polygon)]
            print('pn', polygon_number)
            polygon_image = face_img[polygon_number[0]][polygon_number[1]]
            vertices_position = img_coords[polygon_number[0]][polygon_number[1]]
            print(vertices_position, side_projection, side)
            cv2.imshow('im', polygon_image)
            cv2.waitKey()
            end_matrix = [[0, 0], [0, size[1]], [size[0], size[1]], [size[0], 0]]
            a = i
            if a > 3:
                a = a - 4
            b = a - 1
            if b < 0:
                b = 3

            cv2.imshow('im', polygon_image)
            cv2.waitKey()
            warped = transform_triangle(image=polygon_image, start_points=vertices_position,
                                        triangle_end_points=[side_projection[0], end_matrix[b], end_matrix[a]],
                                        size=300)

            cv2.imshow('im', warped)
            cv2.waitKey()
            if combined is None:
                combined = warped
            else:
                combined = cv2.add(combined, warped)
            i += 1
        cv2.imshow('im', combined)
        cv2.waitKey()
        images.append(combined)
    return images


server_response = get_faces_npz()
print(server_response['face_img'].shape)


images = server_response['face_img'][0]
for f in images:
    cv2.imshow('im', f)
    cv2.waitKey()

res = projection_coordinates(
    server_response['projector'],
    server_response['side'],
    server_response['step'],
    server_response['ij_coords'],
    server_response['xyz_faces'],
    server_response['face_img'],
    server_response['img_coords']
)
print(res[0].shape)
c = 0
for im in res:
    c += 1
    cv2.imwrite(f'{c}.png', im)
print(len(res))

#post_faces_projections_npz(res)