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

import subprocess
import json
import os

class CMakeError(Exception):
    pass

class CMakeMsgLoadError(CMakeError):
    pass

class CMakeMsgDumpError(CMakeError):
    pass

class CMakeMsg:
    BEGIN_MARK = '[== "CMake Server" ==['
    END_MARK = ']== "CMake Server" ==]'

    @classmethod
    def loads(cls, data):
        lpos = data.find(cls.BEGIN_MARK)
        if lpos < 0:
            raise CMakeMsgLoadError()
        lpos += len(cls.BEGIN_MARK)
        rpos = data.rfind(cls.END_MARK)
        if rpos < 0:
            raise CMakeMsgLoadError()
        return json.loads(data[lpos:rpos])

    @classmethod
    def dumps(cls, data):
        return '%s\n%s\n%s\n'%(cls.BEGIN_MARK, json.dumps(data), cls.END_MARK)

    @classmethod
    def load(cls, fd):
        data = ''
        while True:
            line = fd.readline()
            if not line:
                raise CMakeMsgLoadError()
            data += line
            if line.find(cls.END_MARK) >= 0:
                break
        return cls.loads(data)

    @classmethod
    def dump(cls, data, fd):
        data = cls.dumps(data)
        fd.write(data)

class CMakeServer:
    def __init__(self, cmake_command='cmake', version=None):
        self.args = (cmake_command, '-E', 'server', '--experimental', '--debug')

    def start(self):
        self.popen = subprocess.Popen(self.args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
        self.stdin = self.popen.stdin
        self.stdout = self.popen.stdout

class CMakeClient:
    def __init__(self, cmake_server, message_handler=None, progress_handler=None):
        self.server = cmake_server
        self.message_handler = message_handler or self._message_handler
        self.progress_handler = progress_handler or self._progress_handler
        self.hello = CMakeMsg.load(self.server.stdout)
        versions = self.hello['supportedProtocolVersions']
        self.major_version = versions[0]['major']
        self.minor_version = versions[0]['minor']

    @staticmethod
    def _message_handler(message):
        print '-- ' + message

    @staticmethod
    def _progress_handler(progress, message):
        pass

    def call(self, type, **kw):
        data = kw.copy()
        data['type'] = type
        if type == 'handshake' and 'protocolVersion' not in data:
            data['protocolVersion'] = {'major': self.major_version}
        CMakeMsg.dump(data, self.server.stdin)
        while True:
            response = CMakeMsg.load(self.server.stdout)
            if response['type'] == 'message':
                self.message_handler(response['message'])
            elif response['type'] == 'progress':
                mininum = response['progressMinimum']
                maximum =  response['progressMaximum']
                cur = (response['progressCurrent'] - mininum) / float(maximum - mininum)
                self.progress_handler(cur, response['progressMessage'])
            else:
                break
        if response['type'] == 'error':
            raise CMakeError(response['errorMessage'])
        return response

    def handshake(self, sourceDirectory=os.getcwd(), buildDirectory=os.path.abspath('build'), **kw):
        return self.call('handshake', sourceDirectory=sourceDirectory, buildDirectory=buildDirectory, **kw)

    def globalSettings(self):
        return self.call('globalSettings')

    def setGlobalSettings(self, **kw):
        return self.call('setGlobalSettings', **kw)

    def configure(self, cacheArguments=(), **kw):
        return self.call('configure', cacheArguments=cacheArguments, **kw)

    def compute(self):
        return self.call('compute')

    def codemodel(self):
        return self.call('codemodel')

    def cmakeInputs(self):
        return self.call('cmakeInputs')

    def cache(self):
        return self.call('cache')

    def fileSystemWatchers(self):
        return self.call('fileSystemWatchers')

if __name__ == '__main__':
    server = CMakeServer()
    server.start()
    client = CMakeClient(server)
    client.handshake()
    client.configure()
    client.compute()