from light9.namespaces import L9, DEV

from PIL import Image

import numpy

import scipy.misc, scipy.ndimage, scipy.optimize

import cairo

import logging

from light9.effect.settings import DeviceSettings, parseHex

log = logging.getLogger('solve')

# numpy images in this file are (x, y, c) layout.

def numpyFromCairo(surface):

    w, h = surface.get_width(), surface.get_height()

    a = numpy.frombuffer(surface.get_data(), numpy.uint8)

    a.shape = h, w, 4

    a = a.transpose((1, 0, 2))

    return a[:w, :h, :3]

def loadNumpy(path, thumb=(100, 100)):

    img = Image.open(path)

    img.thumbnail(thumb)

    return numpyFromPil(img)

def saveNumpy(path, img):

    # maybe this should only run if log level is debug?

def scaledHex(h, scale):

    rgb = parseHex(h)

    rgb8 = (rgb * scale).astype(numpy.uint8)

    return '#%02x%02x%02x' % tuple(rgb8)

def colorRatio(col1, col2):

    rgb1 = parseHex(col1)

    rgb2 = parseHex(col2)

    def distanceTo(self, img2):

        b = img2.reshape((-1,))

        return 1 - numpy.dot(self.a, b) / self.d

class ImageDistAbs(object):

    def __init__(self, img1):

        self.a = img1

        self.maxDist = img1.shape[0] * img1.shape[1] * img1.shape[2] * 255

    def distanceTo(self, img2):

class Solver(object):

        self.graph = graph

        self.sessions = sessions  # URIs of capture sessions to load

        self.imgSize = imgSize

        self.samples = {}  # uri: Image array (float 0-255)

        self.fromPath = {}  # imagePath: image array

        self.path = {}  # sample: path

        self.blurredSamples = {}

        self.sampleSettings = {}  # sample: DeviceSettings

        self.samplesForDevice = {}  # dev : [(sample, img)]

    def loadSamples(self):

        """learn what lights do from images"""

        log.info('loading...')

        with self.graph.currentState() as g:

                for cap in g.objects(sess, L9['capture']):

                    self._loadSample(g, cap)

        log.info('loaded %s samples', len(self.samples))

    def _loadSample(self, g, samp):

        pathUri = g.value(samp, L9['imagePath'])

        img = loadNumpy(pathUri.replace(L9[''], '')).astype(float)

        settings = DeviceSettings.fromResource(self.graph, samp)

        self.samples[samp] = img

        self.fromPath[pathUri] = img

        self.blurredSamples[samp] = self._blur(img)

            results.append((dist.distanceTo(img2), uri, img2))

        results.sort()

        topDist, topUri, topImg = results[0]

        print('tops2')

        for row in results[:4]:

            print('%.5f' % row[0], row[1][-20:], self.sampleSettings[row[1]])

        #saveNumpy('/tmp/best_in.png', img)

        #saveNumpy('/tmp/best_out.png', topImg)

        #saveNumpy('/tmp/mult.png', topImg / 255 * img)

        return topUri, topDist

        """settings for the given devices that point them each

        at the input image"""

        dist = ImageDist(img)

        devSettings = []

            results = []

            for samp, img2 in self.samplesForDevice[dev]:

                results.append((dist.distanceTo(img2), samp))

            results.sort()

            devSettings.append(s)

        return DeviceSettings.fromList(self.graph, devSettings)

    def blendResults(self, results):

        """list of (dist, settings)"""

        dists = [d for d, sets in results]

        hi = max(dists)

        lo = min(dists)

        n = len(results)

        remappedDists = [1 - (d - lo) / (hi - lo) * n / (n + 1) for d in dists]

        total = sum(remappedDists)

        #print 'blend'

        #for o,n in zip(dists, remappedDists):

        #    print o,n, n / total

        return blend

    def solve(self, painting):

        """

        given strokes of colors on a photo of the stage, figure out the

        best light DeviceSettings to match the image

        """

        pic0Blur = self._blur(pic0)

        sampleDist = {}

        dist = ImageDist(pic0Blur)

        for sample, picSample in sorted(self.blurredSamples.items()):

            #saveNumpy('/tmp/sample_%s.png' % sample.split('/')[-1],

            #          f(picSample))

            sampleDist[sample] = dist.distanceTo(picSample)

        results = sorted([(d, uri) for uri, d in sampleDist.items()])

        sample = results[0][1]

        # this is wrong; some wrong-alignments ought to be dimmer than full

        brightest0 = brightest(pic0)

        #brightestSample = brightest(self.samples[sample])

        if max(brightest0) < 1 / 255:

            return DeviceSettings(self.graph, [])

        #scale = brightest0 / brightestSample

        s = DeviceSettings.fromResource(self.graph, sample)

        # missing color scale, but it was wrong to operate on all devs at once

        return s

    def solveBrute(self, painting):

        colorSteps = 2

        colorStep = 1. / colorSteps

        # use toVector then add ranges

        dims = [

            (DEV['aura1'], L9['rx'], [slice(.2, .7 + .1, .2)]),

            (DEV['aura1'], L9['ry'], [slice(.573, .573 + 1, 1)]),

        ]

        deviceAttrFilter = [(d, a) for d, a, s in dims]

        dist = ImageDist(pic0)

        def drawError(x):

            preview = self.combineImages(self.simulationLayers(settings))

            #saveNumpy('/tmp/x_%s.png' % abs(hash(settings)), preview)

            out = dist.distanceTo(preview)

            #print 'measure at', x, 'drawError=', out

            return out

        if fval > 30000:

            raise ValueError('solution has error of %s' % fval)

    def combineImages(self, layers):

        """make a result image from our self.samples images"""

        out = (next(iter(self.fromPath.values())) * 0).astype(numpy.uint16)

        for layer in layers:

            colorScaled = self.fromPath[layer['path']] * layer['color']

            out += colorScaled.astype(numpy.uint16)

        numpy.clip(out, 0, 255, out)

        return out.astype(numpy.uint8)

    def simulationLayers(self, settings):

        """

            for sample, s in self.sampleSettings.items():

                path = self.path[sample]

                otherDevSettings = s.ofDevice(dev)

                if not otherDevSettings:

                    continue

                dist = devSettings.distanceTo(otherDevSettings)

                log.info('  candidate pic %s %s dist=%s', sample, path, dist)

                candidatePics.append((dist, path, s.getValue(dev, L9['color'])))

            candidatePics.sort()

            # we could even blend multiple top candidates, or omit all

            # of them if they're too far

            bestDist, bestPath, bestPicColor = candidatePics[0]

        return layers

import unittest

import numpy.testing

from . import solve

from rdflib import Namespace

from light9.namespaces import L9, DEV

from light9.effect.settings import DeviceSettings

class TestSolve(unittest.TestCase):

    def setUp(self):

        self.graph = LocalSyncedGraph(

            files=['test/cam/lightConfig.n3', 'test/cam/bg.n3'])

        self.solver = solve.Solver(self.graph,

                                   imgSize=(100, 48),

                                   sessions=[L9['session0']])

        self.solver.loadSamples()

        }], layers)

    def testPerfect2Matches(self):

        layers = self.solver.simulationLayers(

            settings=DeviceSettings(self.graph, [

                (DEV['aura1'], L9['color'], "#ffffff"),

                (DEV['aura1'], L9['rx'], 0.5),

                (DEV['aura1'], L9['ry'], 0.573),

                (DEV['aura2'], L9['color'], "#ffffff"),

                (DEV['aura2'], L9['rx'], 0.7),

                (DEV['aura2'], L9['ry'], 0.573),

            ]))

            {

                'path': CAM_TEST['bg2-d.jpg'],

                'color': (1, 1, 1)

            },

            {

                'path': CAM_TEST['bg2-f.jpg'],

                'color': (1, 1, 1)

            },

        ], layers)

class TestCombineImages(unittest.TestCase):

    def setUp(self):

        graph = LocalSyncedGraph(

            files=['test/cam/lightConfig.n3', 'test/cam/bg.n3'])

        self.solver = solve.Solver(graph,

                                   imgSize=(100, 48),

                                   sessions=[L9['session0']])

        self.solver.loadSamples()

        out = self.solver.combineImages(layers=[

            {

                'path': CAM_TEST['bg2-d.jpg'],

                'color': (.2, .2, .3)

            },

            {

                'path': CAM_TEST['bg2-a.jpg'],

                'color': (.888, 0, .3)

            },

        ])

        solve.saveNumpy('/tmp/t.png', out)

        golden = solve.loadNumpy('test/cam/layers_out1.png')

        self.solver.loadSamples()

    def testRightSide(self):

        drawingOnRight = {

            "strokes": [{

                "pts": [[0.875, 0.64], [0.854, 0.644]],

                "color": "#aaaaaa"

            }]

        }

        drawImg = self.solver.draw(drawingOnRight)

        match, dist = self.solver.bestMatch(drawImg)

        self.assertEqual(L9['sample5'], match)