from onvif import ONVIFCamera
import os
import io
import rtsp
import requests

class Camera:
    def __init__(self, ip, port, user='admin', password='Supervisor'):
        self.ip = ip
        self.port = port
        self.user = user
        self.password = password
        self.cam = ONVIFCamera(ip, port, user, password)
        self.media = self.cam.create_media_service()
        self.imaging = self.cam.create_imaging_service()
        self.vstoken = self.media.GetVideoSources()[0]._token
        self.request = self.imaging.create_type("SetImagingSettings")
        self.request.VideoSourceToken = self.vstoken

    def GetImagingSettings(self):
        return self.imaging.GetImagingSettings({'VideoSourceToken': self.vsctoken })

    def GetSnapshotUri(self):
        uri = None
        token = self.media.GetProfiles()[0]._token

        try:
            uri = self.media.GetSnapshotUri({'ProfileToken': token}).Uri
        except Exception as e:
            pass

        return uri

    def get_private_stream_url(self):
        uri = None
        token = self.media.GetProfiles()[0]._token

        obj = self.media.create_type('GetStreamUri')
        obj.ProfileToken = token
        obj.StreamSetup = {
            'Stream': 'RTP-Unicast',
            'Transport': {'Protocol': 'RTSP'}
        }

        try:
            uri = self.media.GetStreamUri(obj).Uri
            if len(self.user + self.password) > 0:
                uri = uri[:7] + self.user + ':' + self.password + "@" + uri[7:]

        except Exception as e:
            pass

        return uri


    def get_public_snapshot_url(self):
        # make sure that snapshots folder is exists
        if not os.path.isdir('snapshots'):
            os.makedirs('snapshots')

        private_uri = self.GetSnapshotUri()
        if private_uri is not None:
            try:
                r = requests.get(private_uri, auth=(self.user, self.password))

                if r.ok:
                    filename = 'snapshots/' + self.ip + ":" + str(self.port) + '.jpg'
                    with open(filename, 'wb') as snapshot:
                        snapshot.write(r.content)
                    return "/" + filename
            except Exception as e:
                print('get_public_snapshot_url: request error: ', e)


        # try to get snapshot from stream
        private_stream_url = self.get_private_stream_url()

        if private_stream_url is not None:
            client = rtsp.Client(rtsp_server_uri=private_stream_url, verbose=False)
            image = client.read()

            if image is not None:
                imgByteArr = io.BytesIO()
                image.save(imgByteArr, format='jpeg')
                image = imgByteArr.getvalue()

            client.close()
            filename = 'snapshots/' + self.ip + ":" + str(self.port) + '.jpg'

            with open(filename, 'wb') as snapshot:
                snapshot.write(image)

            return "/" + filename

        return None

    def CreateRequest(self):
        self.request.ImagingSettings = self.GetImagingSettings()
        return self.request

    def GetImagingSettings(self):
        return self.imaging.GetImagingSettings({'VideoSourceToken': self.vstoken })

    def GetBrightness(self):
        try:
            brightness = self.imaging.GetImagingSettings({'VideoSourceToken': self.vstoken}).Brightness
        except:
            brightness = None
        return brightness

    def GetColorSaturation(self):
        try:
            saturation = self.imaging.GetImagingSettings({'VideoSourceToken': self.vstoken}).ColorSaturation
        except:
            saturation = None
        return saturation

    def GetContrast(self):
        try:
            contrast = self.imaging.GetImagingSettings({'VideoSourceToken': self.vstoken}).Contrast
        except:
            contrast = None
        return contrast

    def SetExposureMode(self, mode):
        request = self.CreateRequest()
        request.ImagingSettings.Exposure.Mode = mode
        return self.imaging.SetImagingSettings(request)

    def SetWhiteBalanceMode(self, mode):
        request = self.CreateRequest()
        request.ImagingSettings.WhiteBalance.Mode = mode
        return self.imaging.SetImagingSettings(request)

    def SetColorSaturation(self, saturation):
        request = self.CreateRequest()
        request.ImagingSettings.ColorSaturation = saturation
        return self.imaging.SetImagingSettings(request)

    def SetBrightness(self, brightness):
        request = self.CreateRequest()
        request.ImagingSettings.Brightness = brightness
        return self.imaging.SetImagingSettings(request)

    def SetContrast(self, contrast):
        request = self.CreateRequest()
        request.ImagingSettings.Contrast = contrast
        return self.imaging.SetImagingSettings(request)

    def SetExposureGain(self, gain):
        request = self.CreateRequest()
        request.ImagingSettings.Exposure.Gain = gain
        return self.imaging.SetImagingSettings(request)

    def SetExposureTime(self, time):
        request = self.CreateRequest()
        request.ImagingSettings.Exposure.ExposureTime = time
        return self.imaging.SetImagingSettings(request)

    def SetExposureIris(self, iris):
        request = self.CreateRequest()
        request.ImagingSettings.Exposure.Iris = iris
        return self.imaging.SetImagingSettings(request)

    def SetWbCrGain(self, crgain):
        request = self.CreateRequest()
        request.ImagingSettings.WhiteBalance.CrGain = crgain
        self.imaging.SetImagingSettings(request)

    def SetWbCbGain(self, cbgain):
        request = self.CreateRequest()
        request.ImagingSettings.WhiteBalance.CbGain = cbgain
        self.imaging.SetImagingSettings(request)