import sys
import os
import uu
from io import BytesIO
import json
import numpy as np
import zlib

original = None

def redirect_on(file = None):
  global original
  if original == None:
    original = sys.stdout
    if file == None:
      file = os.devnull
    sys.stdout = open(file, 'w')

def redirect_off():
  global original
  if original != None:
    sys.stdout.close()
    sys.stdout = original
    original = None


def zlib_uuencode(databytes, name='<data>'):
  ''' Compress databytes with zlib & uuencode the result '''
  inbuff = BytesIO(zlib.compress(databytes, 9))
  outbuff = BytesIO()
  uu.encode(inbuff, outbuff, name=name)
  return outbuff.getvalue()

def zlib_uudecode(databytes):
  ''' uudecode databytes and decompress the result with zlib '''
  inbuff = BytesIO(databytes)
  outbuff = BytesIO()
  uu.decode(inbuff, outbuff)
  return zlib.decompress(outbuff.getvalue())

class NpEncoder(json.JSONEncoder):
  def default(self, obj):
    if isinstance(obj, np.integer):
      return int(obj)
    if isinstance(obj, np.floating):
      return float(obj)
    if isinstance(obj, np.ndarray):
      return obj.tolist()

def findCosineDistance(source_representation, test_representation):
  if type(source_representation) == list:
    source_representation = np.array(source_representation)
  if type(test_representation) == list:
    test_representation = np.array(test_representation)
  a = np.matmul(np.transpose(source_representation), test_representation)
  b = np.sum(np.multiply(source_representation, source_representation))
  c = np.sum(np.multiply(test_representation, test_representation))
  return 1 - (a / (np.sqrt(b) * np.sqrt(c)))

def findEuclideanDistance(source_representation, test_representation):
  if type(source_representation) == list:
    source_representation = np.array(source_representation)
  if type(test_representation) == list:
    test_representation = np.array(test_representation)
  euclidean_distance = source_representation - test_representation
  euclidean_distance = np.sum(np.multiply(euclidean_distance, euclidean_distance))
  euclidean_distance = np.sqrt(euclidean_distance)
  return euclidean_distance

def l2_normalize(x):
  return x / np.sqrt(np.sum(np.multiply(x, x)))