from header import *


#from core.models.service import Service
from core.models import Service


#from core.models.tenantwithcontainer import TenantWithContainer
from core.models import TenantWithContainer


class VSGService(Service):

  KIND = "vCPE"

  class Meta:
      app_label = "vsg"
      name = "vsg"
      verbose_name = "vSG Service"

  # Primitive Fields (Not Relations)
  url_filter_kind = StrippedCharField( blank = True, max_length = 30, null = True, db_index = False, choices = ((None, 'None'), ('safebrowsing', 'Safe Browsing'), ('answerx', 'AnswerX')) )
  dns_servers = StrippedCharField( default = "8.8.8.8", max_length = 255, null = False, db_index = False, blank = False )
  node_label = StrippedCharField( db_index = False, max_length = 30, null = True, blank = True )
  docker_image_name = StrippedCharField( default = "docker.io/xosproject/vsg", max_length = 255, null = False, db_index = False, blank = False )
  docker_insecure_registry = BooleanField( default = False, null = False, blank = True, db_index = False )
  

  # Relations
  

  pass


class VSGTenant(TenantWithContainer):

  KIND = "vCPE"

  class Meta:
      app_label = "vsg"
      name = "vsg"
      verbose_name = "vSG Service"

  # Primitive Fields (Not Relations)
  last_ansible_hash = StrippedCharField( db_index = False, max_length = 128, null = True, blank = True )
  

  # Relations
  

  sync_attributes = ("wan_container_ip", "wan_container_mac", "wan_container_netbits",
                     "wan_container_gateway_ip", "wan_container_gateway_mac",
                     "wan_vm_ip", "wan_vm_mac")
  
  def __init__(self, *args, **kwargs):
      super(VSGTenant, self).__init__(*args, **kwargs)
      self.cached_vrouter=None
  
  @property
  def vrouter(self):
      vrouter = self.get_newest_subscribed_tenant(VRouterTenant)
      if not vrouter:
          return None
  
      # always return the same object when possible
      if (self.cached_vrouter) and (self.cached_vrouter.id == vrouter.id):
          return self.cached_vrouter
  
      vrouter.caller = self.creator
      self.cached_vrouter = vrouter
      return vrouter
  
  @vrouter.setter
  def vrouter(self, value):
      raise XOSConfigurationError("VSGTenant.vrouter setter is not implemented")
  
  @property
  def volt(self):
      from services.volt.models import VOLTTenant
      if not self.subscriber_tenant:
          return None
      volts = VOLTTenant.objects.filter(id=self.subscriber_tenant.id)
      if not volts:
          return None
      return volts[0]
  
  @volt.setter
  def volt(self, value):
      raise XOSConfigurationError("VSGTenant.volt setter is not implemented")
  
  @property
  def ssh_command(self):
      if self.instance:
          return self.instance.get_ssh_command()
      else:
          return "no-instance"
  
  def get_vrouter_field(self, name, default=None):
      if self.vrouter:
          return getattr(self.vrouter, name, default)
      else:
          return default
  
  @property
  def wan_container_ip(self):
      return self.get_vrouter_field("public_ip", None)
  
  @property
  def wan_container_mac(self):
      return self.get_vrouter_field("public_mac", None)
  
  @property
  def wan_container_netbits(self):
      return self.get_vrouter_field("netbits", None)
  
  @property
  def wan_container_gateway_ip(self):
      return self.get_vrouter_field("gateway_ip", None)
  
  @property
  def wan_container_gateway_mac(self):
      return self.get_vrouter_field("gateway_mac", None)
  
  @property
  def wan_vm_ip(self):
      tags = Tag.select_by_content_object(self.instance).filter(name="vm_vrouter_tenant")
      if tags:
          tenant = VRouterTenant.objects.get(id=tags[0].value)
          return tenant.public_ip
      else:
          raise Exception("no vm_vrouter_tenant tag for instance %s" % o.instance)
  
  @property
  def wan_vm_mac(self):
      tags = Tag.select_by_content_object(self.instance).filter(name="vm_vrouter_tenant")
      if tags:
          tenant = VRouterTenant.objects.get(id=tags[0].value)
          return tenant.public_mac
      else:
          raise Exception("no vm_vrouter_tenant tag for instance %s" % o.instance)
  
  @property
  def is_synced(self):
      return (self.enacted is not None) and (self.enacted >= self.updated)
  
  @is_synced.setter
  def is_synced(self, value):
      pass
  
  def get_vrouter_service(self):
      vrouterServices = VRouterService.get_service_objects().all()
      if not vrouterServices:
          raise XOSConfigurationError("No VROUTER Services available")
      return vrouterServices[0]
  
  def manage_vrouter(self):
      # Each vCPE object owns exactly one vRouterTenant object
  
      if self.deleted:
          return
  
      if self.vrouter is None:
          vrouter = self.get_vrouter_service().get_tenant(address_pool_name="addresses_vsg", subscriber_tenant = self)
          vrouter.caller = self.creator
          vrouter.save()
  
  def cleanup_vrouter(self):
      if self.vrouter:
          # print "XXX cleanup vrouter", self.vrouter
          self.vrouter.delete()
  
  def cleanup_orphans(self):
      # ensure vCPE only has one vRouter
      cur_vrouter = self.vrouter
      for vrouter in list(self.get_subscribed_tenants(VRouterTenant)):
          if (not cur_vrouter) or (vrouter.id != cur_vrouter.id):
              # print "XXX clean up orphaned vrouter", vrouter
              vrouter.delete()
  
      if self.orig_instance_id and (self.orig_instance_id != self.get_attribute("instance_id")):
          instances=Instance.objects.filter(id=self.orig_instance_id)
          if instances:
              # print "XXX clean up orphaned instance", instances[0]
              instances[0].delete()
  
  def get_slice(self):
      if not self.provider_service.slices.count():
          print self, "dio porco"
          raise XOSConfigurationError("The service has no slices")
      slice = self.provider_service.slices.all()[0]
      return slice
  
  def get_vsg_service(self):
      return VSGService.get_service_objects().get(id=self.provider_service.id)
  
  def find_instance_for_s_tag(self, s_tag):
      #s_tags = STagBlock.objects.find(s_s_tag)
      #if s_tags:
      #    return s_tags[0].instance
  
      tags = Tag.objects.filter(name="s_tag", value=s_tag)
      if tags:
          return tags[0].content_object
  
      return None
  
  def find_or_make_instance_for_s_tag(self, s_tag):
      instance = self.find_instance_for_s_tag(self.volt.s_tag)
      if instance:
          return instance
  
      flavors = Flavor.objects.filter(name="m1.small")
      if not flavors:
          raise XOSConfigurationError("No m1.small flavor")
  
      slice = self.provider_service.slices.all()[0]
  
      if slice.default_isolation == "container_vm":
          (node, parent) = ContainerVmScheduler(slice).pick()
      else:
          (node, parent) = LeastLoadedNodeScheduler(slice, label=self.get_vsg_service().node_label).pick()
  
      instance = Instance(slice = slice,
                      node = node,
                      image = self.image,
                      creator = self.creator,
                      deployment = node.site_deployment.deployment,
                      flavor = flavors[0],
                      isolation = slice.default_isolation,
                      parent = parent)
  
      self.save_instance(instance)
  
      return instance
  
  def manage_container(self):
      from core.models import Instance, Flavor
  
      if self.deleted:
          return
  
      # For container or container_vm isolation, use what TenantWithCotnainer
      # provides us
      slice = self.get_slice()
      if slice.default_isolation in ["container_vm", "container"]:
          super(VSGTenant,self).manage_container()
          return
  
      if not self.volt:
          raise XOSConfigurationError("This vCPE container has no volt")
  
      if self.instance:
          # We're good.
          return
  
      instance = self.find_or_make_instance_for_s_tag(self.volt.s_tag)
      self.instance = instance
      super(TenantWithContainer, self).save()
  
  def cleanup_container(self):
      if self.get_slice().default_isolation in ["container_vm", "container"]:
          super(VSGTenant,self).cleanup_container()
  
      # To-do: cleanup unused instances
      pass
  
  def find_or_make_port(self, instance, network, **kwargs):
      port = Port.objects.filter(instance=instance, network=network)
      if port:
          port = port[0]
      else:
          port = Port(instance=instance, network=network, **kwargs)
          port.save()
      return port
  
  def get_lan_network(self, instance):
      slice = self.provider_service.slices.all()[0]
      # there should only be one network private network, and its template should not be the management template
      lan_networks = [x for x in slice.networks.all() if x.template.visibility=="private" and (not "management" in x.template.name)]
      if len(lan_networks)>1:
          raise XOSProgrammingError("The vSG slice should only have one non-management private network")
      if not lan_networks:
          raise XOSProgrammingError("No lan_network")
      return lan_networks[0]
  
  def save_instance(self, instance):
      with transaction.atomic():
          instance.volumes = "/etc/dnsmasq.d,/etc/ufw"
          super(VSGTenant, self).save_instance(instance)
  
          if instance.isolation in ["container", "container_vm"]:
              lan_network = self.get_lan_network(instance)
              port = self.find_or_make_port(instance, lan_network, ip="192.168.0.1", port_id="unmanaged")
              port.set_parameter("c_tag", self.volt.c_tag)
              port.set_parameter("s_tag", self.volt.s_tag)
              port.set_parameter("device", "eth1")
              port.set_parameter("bridge", "br-lan")
  
              wan_networks = [x for x in instance.slice.networks.all() if "wan" in x.name]
              if not wan_networks:
                  raise XOSProgrammingError("No wan_network")
              port = self.find_or_make_port(instance, wan_networks[0])
              port.set_parameter("next_hop", value="10.0.1.253")   # FIX ME
              port.set_parameter("device", "eth0")
  
          if instance.isolation in ["vm"]:
              lan_network = self.get_lan_network(instance)
              port = self.find_or_make_port(instance, lan_network)
              port.set_parameter("c_tag", self.volt.c_tag)
              port.set_parameter("s_tag", self.volt.s_tag)
              port.set_parameter("neutron_port_name", "stag-%s" % self.volt.s_tag)
              port.save()
  
          # tag the instance with the s-tag, so we can easily find the
          # instance later
          if self.volt and self.volt.s_tag:
              tags = Tag.objects.filter(name="s_tag", value=self.volt.s_tag)
              if not tags:
                  tag = Tag(service=self.provider_service, content_object=instance, name="s_tag", value=self.volt.s_tag)
                  tag.save()
  
          # VTN-CORD needs a WAN address for the VM, so that the VM can
          # be configured.
          tags = Tag.select_by_content_object(instance).filter(name="vm_vrouter_tenant")
          if not tags:
              vrouter = self.get_vrouter_service().get_tenant(address_pool_name="addresses_vsg", subscriber_service = self.provider_service)
              vrouter.set_attribute("tenant_for_instance_id", instance.id)
              vrouter.save()
              tag = Tag(service=self.provider_service, content_object=instance, name="vm_vrouter_tenant", value="%d" % vrouter.id)
              tag.save()
  
  def save(self, *args, **kwargs):
      if not self.creator:
          if not getattr(self, "caller", None):
              # caller must be set when creating a vCPE since it creates a slice
              raise XOSProgrammingError("VSGTenant's self.caller was not set")
          self.creator = self.caller
          if not self.creator:
              raise XOSProgrammingError("VSGTenant's self.creator was not set")
  
      super(VSGTenant, self).save(*args, **kwargs)
      model_policy_vcpe(self.pk)
  
  def delete(self, *args, **kwargs):
      self.cleanup_vrouter()
      self.cleanup_container()
      super(VSGTenant, self).delete(*args, **kwargs)
  
  pass

def model_policy_vcpe(pk):
    # TODO: this should be made in to a real model_policy
    with transaction.atomic():
        vcpe = VSGTenant.objects.select_for_update().filter(pk=pk)
        if not vcpe:
            return
        vcpe = vcpe[0]
        vcpe.manage_container()
        vcpe.manage_vrouter()
        vcpe.cleanup_orphans()