import json

from django.shortcuts import render
from django.views.decorators.csrf import csrf_exempt
from pywt import dwt2, idwt2

from .helper import *

PREFIX = 'media/'

DEFAULT_FORMAT = '.jpg'


@csrf_exempt
def upload(request):
    if request.method == 'POST':
        imageName = get_image(request)
        if imageName == '':
            return HttpResponse('Not supported image format')
        return HttpResponse(imageName)
    return HttpResponse('Please use POST')


@csrf_exempt
def basic_drawing(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        draw_type = para.get('type', 'bg')
        if draw_type == 'bg':
            return HttpResponse(process_bg())
        else:
            if draw_type == 'line':
                return HttpResponse(process_line(para))
            elif draw_type == 'rectangle':
                return HttpResponse(process_rectangle(para))
            elif draw_type == 'circle':
                return HttpResponse(process_circle(para))
            elif draw_type == 'ellipse':
                return HttpResponse(process_ellipse(para))
            elif draw_type == 'polylines':
                return HttpResponse(process_polylines(para))
            elif draw_type == 'text':
                return HttpResponse(process_text(para))
    return HttpResponse('Please use POST')


@csrf_exempt
def rgb_color_space(request, color):
    if request.method == 'POST':
        para = json.loads(request.body)
        image_name = para['img']
        img = cv2.imread(PREFIX + image_name)
        data = None
        if color == 'r':
            data = img[:, :, 2]
        elif color == 'g':
            data = img[:, :, 1]
        elif color == 'b':
            data = img[:, :, 0]
        if para.get('filter', False):
            data = process_filter_rgb(para, data)
        filename = color + '-' + image_name
        cv2.imwrite(PREFIX + filename, data)
        return HttpResponse(filename)
    return HttpResponse('Please use POST')


@csrf_exempt
def hsv_color_space(request, color):
    if request.method == 'POST':
        para = json.loads(request.body)
        image_name = para['img']
        img = cv2.imread(PREFIX + image_name)
        hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
        data = None
        if color == 'h':
            data = hsv[:, :, 0]
        elif color == 's':
            data = hsv[:, :, 1]
        elif color == 'v':
            data = hsv[:, :, 2]
        elif color == 'filter':
            upper_bound = para.get('ub', [200, 40, 100])
            lower_bound = para.get('lb', [0, 0, 0])
            data = cv2.inRange(hsv, np.array(lower_bound), np.array(upper_bound))
        filename = color + '-' + image_name
        cv2.imwrite(PREFIX + filename, data)
        return HttpResponse(filename)
    return HttpResponse('Please use POST')


@csrf_exempt
def basic_operation(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        operator = para.get('operator', 'and')
        img = para['img']
        has_color = para.get('color', 0)
        base = para.get('base', 1)
        if operator == 'and':
            return HttpResponse(logic_and(img, has_color, base))
        elif operator == 'or':
            return HttpResponse(logic_or(img, has_color, base))
        elif operator == 'not':
            return HttpResponse(logic_not(img, has_color, base))
        elif operator == 'add':
            return HttpResponse(arithmetic_add(img, has_color, base))
        elif operator == 'sub':
            return HttpResponse(arithmetic_sub(img, has_color, base))
        elif operator == 'multi':
            return HttpResponse(arithmetic_multi(img, has_color, base))
        elif operator == 'div':
            return HttpResponse(arithmetic_div(img, has_color, base))
    return HttpResponse('Please use POST')


@csrf_exempt
def resize(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        img = cv2.imread(PREFIX + image)
        size = para.get('size', None)
        if size is not None:
            height, width = img.shape[:2]
            if width * height >= size[0] * size[1]:
                interpolation = cv2.INTER_AREA
            else:
                interpolation = cv2.INTER_CUBIC
            img = cv2.resize(img, tuple(size), interpolation)
        else:
            multiple = para.get('multiple', 2)
            if multiple < 1:
                interpolation = cv2.INTER_AREA
            else:
                interpolation = cv2.INTER_CUBIC
            img = cv2.resize(img, (0, 0), fx=multiple, fy=multiple, interpolation=interpolation)
        return HttpResponse(save_image(img))
    return HttpResponse('Please use POST')


@csrf_exempt
def rotate(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        img = cv2.imread(PREFIX + image)
        angle = para.get('angle', 45)
        img = rotate_bound(img, angle)
        return HttpResponse(save_image(img))
    return HttpResponse('Please use POST')


@csrf_exempt
def translation(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        img = cv2.imread(PREFIX + image)
        offset = para.get('offset', [30, 60])
        height, width = img.shape[:2]
        M = np.float32([[1, 0, offset[0]], [0, 1, offset[1]]])
        img = cv2.warpAffine(img, M, (width, height))
        return HttpResponse(save_image(img))
    return HttpResponse('Please use POST')


@csrf_exempt
def flip(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        img = cv2.imread(PREFIX + image)
        flip_code = para.get('flip', 1)
        img = cv2.flip(img, flip_code)
        return HttpResponse(save_image(img))
    return HttpResponse('Please use POST')


@csrf_exempt
def affine(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        img = cv2.imread(PREFIX + image)
        before = np.float32(para.get('before', [[50, 50], [200, 50], [50, 200]]))
        after = np.float32(para.get('after', [[10, 100], [200, 50], [100, 250]]))
        rows, cols = img.shape[:2]
        M = cv2.getAffineTransform(before, after)
        img = cv2.warpAffine(img, M, (rows, cols))
        return HttpResponse(save_image(img))
    return HttpResponse('Please use POST')


@csrf_exempt
def histogram(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        color = para.get('color', False)
        histogram_name = get_image_name() + DEFAULT_FORMAT
        if color:
            img = cv2.imread(PREFIX + image)
            hist_cover_rgb(img, PREFIX + histogram_name)
        else:
            img = cv2.imread(PREFIX + image, 0)
            hist_cover_gray(img, PREFIX + histogram_name)
        return HttpResponse(histogram_name)
    return HttpResponse('Please use POST')


@csrf_exempt
def piecewise_linear_transform(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        img = cv2.imread(PREFIX + image, 0)
        funcs = para.get('func', [
            {
                "limit": 50,
                "k": 0.5,
                "b": 0
            },
            {
                "limit": 150,
                "k": 3.6,
                "b": -310

            },
            {
                "limit": -1,
                "k": 0.238,
                "b": 194
            }
        ])
        ret_name1 = get_image_name() + DEFAULT_FORMAT
        ret_name2 = get_image_name() + DEFAULT_FORMAT
        out_name = get_image_name() + DEFAULT_FORMAT
        h, w = img.shape[:2]
        out = np.zeros(img.shape, np.uint8)
        for i in range(h):
            for j in range(w):
                pix = img[i][j]
                last_limit = float("-inf")
                for func in funcs:
                    limit = func['limit']
                    k = func['k']
                    b = func['b']
                    if limit == -1:
                        if pix > last_limit:
                            out[i][j] = k * pix + b
                    else:
                        if last_limit <= pix < limit:
                            out[i][j] = k * pix + b
                    last_limit = limit
        out = np.around(out).astype(np.uint8)
        cv2.imwrite(PREFIX + out_name, out)
        grayHist(img, PREFIX + ret_name1)
        grayHist(out, PREFIX + ret_name2)
        return HttpResponse([{"orig": image, "hist": ret_name1}, {"orig": out_name, "hist": ret_name2}])
    return HttpResponse('Please use POST')


@csrf_exempt
def edge_detection(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        img = cv2.imread(PREFIX + image, 0)
        operator = para.get('operator', 'Roberts')
        if operator == 'Roberts':
            img = process_roberts(img)
        elif operator == 'Sobel':
            img = process_sobel(img)
        elif operator == 'Laplacian':
            img_gaussianBlur = cv2.GaussianBlur(img, (5, 5), 0)
            img = process_laplacian(img_gaussianBlur)
        elif operator == 'LoG':
            img = process_LoG(img)
        elif operator == 'Canny':
            img = process_Canny(img)
        # 这里由于返回格式的不同，会在process_enhance之中直接返回，不在往后执行
        elif operator == 'Enhance':
            return process_enhance(img)
        return HttpResponse(save_image(img))
    return HttpResponse('Please use POST')


@csrf_exempt
def line_change_detection(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        img = cv2.imread(PREFIX + image)
        use_p = para.get('use_p', True)
        img = cv2.GaussianBlur(img, (3, 3), 0)
        edges = cv2.Canny(img, 50, 150, apertureSize=3)
        if use_p:
            img = process_lcd_with_p(edges, img)
        else:
            img = process_lcd_without_p(edges, img)
        return HttpResponse(save_image(img))
    return HttpResponse('Please use POST')


@csrf_exempt
def smooth(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        img = cv2.imread(PREFIX + image, 0)
        # frequency domain
        fd = para.get('fd', True)
        my_filter = para.get('filter', 'ideal_low_pass_filter')
        if fd:
            if my_filter == 'ideal_low_pass_filter':
                d0 = para.get('d0', 20)
                img = filter_use_smooth(img, ideal_low_filter(img, d0))
            elif my_filter == 'butterworth_low_pass_filter':
                d0 = para.get('d0', 20)
                rank = para.get('rank', 2)
                img = filter_use_smooth(img, butterworth_low_pass_filter(img, d0, rank))
            elif my_filter == 'gauss_low_pass_filter':
                d0 = para.get('d0', 20)
                img = filter_use_smooth(img, gauss_low_pass_filter(img, d0))
        else:
            size = para.get('size', 3)
            if my_filter == 'average':
                img = cv2.blur(img, (size, size))
            elif my_filter == 'median':
                img = cv2.medianBlur(img, size)
        return HttpResponse(save_image(img))
    return HttpResponse('Please use POST')


@csrf_exempt
def sharpen(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        img = cv2.imread(PREFIX + image, 0)
        # frequency domain
        fd = para.get('fd', True)
        my_filter = para.get('filter', ideal_high_pass_filter)
        if fd:
            if my_filter == 'ideal_high_pass_filter':
                d0 = para.get('d0', 40)
                img = filter_use_sharpen(img, ideal_high_pass_filter(img, d0))
            elif my_filter == 'butterworth_high_pass_filter':
                d0 = para.get('d0', 20)
                rank = para.get('rank', 2)
                img = filter_use_sharpen(img, butterworth_high_pass_filter(img, d0, rank))
            elif my_filter == 'gauss_high_pass_filter':
                d0 = para.get('d0', 20)
                img = filter_use_sharpen(img, gauss_high_pass_filter(img, d0))
        else:
            if my_filter == 'Roberts':
                img = process_roberts(img)
            elif my_filter == 'Sobel':
                img = process_sobel(img)
            elif my_filter == 'Prewitt':
                img = process_prewitt(img)
            elif my_filter == 'Laplacian':
                img = process_laplacian(img)
        return HttpResponse(save_image(img))
    return HttpResponse('Please use POST')


@csrf_exempt
def morphology(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        size = para.get('size', 5)
        img = cv2.imread(PREFIX + image, 0)
        retval, img = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)
        kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (size, size))
        op = para.get('type', 'open')
        if op == 'open':
            img = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)
        elif op == 'close':
            img = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
        elif op == 'erode':
            img = cv2.erode(img, kernel)
        elif op == 'dilate':
            img = cv2.dilate(img, kernel)
        return HttpResponse(save_image(img))
    return HttpResponse('Please use POST')


@csrf_exempt
def noise(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        img = cv2.imread(PREFIX + image)
        op = para.get('type', 'gauss')
        if op == 'gauss':
            img = process_gauss_noise(img)
        elif op == 'salt_and_pepper':
            img = process_salt_and_peper_noise(img, para)
        return HttpResponse(save_image(img))
    return HttpResponse('Please use POST')


@csrf_exempt
def filtration(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        img = cv2.imread(PREFIX + image, 0)
        op = para.get('type', 'mean')
        detail_type = para.get('detail_type', 'arithmetic')
        if op == 'mean':
            if detail_type == 'arithmetic':
                img = process_arithmetic_mean(img)
            elif detail_type == 'geometric':
                img = process_geometric_mean(img)
            elif detail_type == 'harmonic':
                img = process_harmonic_filter(img)
        elif op == 'sort':
            if detail_type == 'max':
                img = process_max_sort(img)
            elif detail_type == 'median':
                img = process_median_sort(img)
            elif detail_type == 'min':
                img = process_min_sort(img)
        elif op == 'choice':
            if detail_type == 'low':
                limit = para.get('limit', 20)
                img = process_low_choice(img, limit)
            elif detail_type == 'high':
                limit = para.get('limit', 200)
                img = process_high_choice(img, limit)
            elif detail_type == 'pass':
                min_r = para.get('min', 20)
                max_r = para.get('max', 200)
                img = process_pass_choice(img, min_r, max_r)
            elif detail_type == 'stop':
                min_r = para.get('min', 20)
                max_r = para.get('max', 200)
                img = process_stop_choice(img, min_r, max_r)
        return HttpResponse(save_image(img))
    return HttpResponse('Please use POST')


@csrf_exempt
def wavelet(request):
    if request.method == 'POST':
        print(request.body)
        para = json.loads(request.body)

        image = para['img']
        img = cv2.imread(PREFIX + image, 0)
        # 对img进行haar小波变换：
        cA, (cH, cV, cD) = dwt2(img, 'haar')
        rimg = idwt2((cA, (cH, cV, cD)), 'haar')
        ret = [
            {"low": save_image(np.uint8(cA / np.max(cA) * 255)),
             "horizontal_high": save_image(np.uint8(cH / np.max(cH) * 255)),
             "vertical_high": save_image(np.uint8(cV / np.max(cV) * 255)),
             "diagonal_high": save_image(np.uint8(cD / np.max(cD) * 255)),
             "refactor": save_image(np.uint8(rimg))
             }
        ]
        return HttpResponse(ret)
    return HttpResponse('Please use POST')


@csrf_exempt
def fourier(request):
    if request.method == 'POST':
        para = json.loads(request.body)
        image = para['img']
        img = cv2.imread(PREFIX + image, 0)
        # 傅里叶
        f = np.fft.fft2(img)
        fshift = np.fft.fftshift(f)
        magnitude_spectrum = 20 * np.log(np.abs(fshift))
        # 逆傅里叶
        ishift = np.fft.ifftshift(f)
        iimg = np.fft.ifft2(ishift)
        iimg = np.abs(iimg)
        ret = [{"fourier_transform": save_image(magnitude_spectrum), "inverse": save_image(iimg)}]
        return HttpResponse(ret)
    return HttpResponse('Please use POST')


def load(request):
    return render(request, '小波变换.html')