from common.common import CostDetail
from pprint import pprint


class GCPProcesser:
    def __init__(self, data, provider, date_str):
        self.data = data
        self.provider = provider
        self.pre_task = [MergeCostByService()]
        self.date = date_str
        self.task = [DealGCSCost(self.provider, self.date),
                     DealArmorFixedCost(self.provider, self.date),
                     DealArmorCost(self.provider, self.date),
                     DealDataTransferCost(self.provider, self.date),
                     DealArtifactRegistryCost(self.provider, self.date),
                     DealPDCost(self.provider, self.date),
                     DealNatGatewayFixedCost(self.provider, self.date),
                     DealNatGatewayCost(self.provider, self.date),
                     DealCECost(self.provider, self.date),
                     DealGKSCost(self.provider, self.date),
                     DealELBFixedCost(self.provider, self.date),
                     DealELBCost(self.provider, self.date)]
        self.pre_result = {}

    def process(self, region):
        pre_result = {}
        if self.pre_result == {}:
            for task in self.pre_task:
                pre_result = task.deal(self.data)
            self.pre_result = pre_result
        final = []
        for task in self.task:
            cost = task.deal(self.pre_result, region)
            final.append(cost)
        return final


class MergeCostByService:
    def deal(self, data):
        # region,service split
        # "us-west1": {'Kubernetes Engine':{"Regional Kubernetes Clusters":"0.053666"}}
        # region may None ,must deal this case
        result = {}
        for row in data:
            if row.region not in result:
                result[row.region] = {
                    row.cloud_service: {row.cloud_sku: row.total_cost}
                }
            else:
                if row.cloud_service not in result[row.region]:
                    result[row.region][row.cloud_service] = {
                        row.cloud_sku: row.total_cost}
                else:
                    if row.cloud_sku not in result[row.region][row.cloud_service]:
                        result[row.region][row.cloud_service][row.cloud_sku] = row.total_cost
                    else:
                        result[row.region][row.cloud_service][row.cloud_sku] += row.total_cost
        pprint(result)
        return result


# Cloud Storage
class DealGCSCost:
    def __init__(self, provider, date_str):
        self.service = "Simple Storage Service"
        self.inner_service = "Cloud Storage"
        self.provider = provider
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data, region):
        # deal gcs cost
        cost = float(0)
        if region in data:
            if self.inner_service in data[region]:
                for key, value in data[region][self.inner_service].items():
                    cost += float(value)
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# GCP Cloud Armor fixed cost
# e.g. Policy and Rule


class DealArmorFixedCost:
    def __init__(self, provider, date_str):
        self.service = "WAF"
        self.inner = "Networking"
        self.inner_service = "Cloud Armor"
        self.provider = provider
        self.fixed_cost = True
        self.date = date_str

    def deal(self, data, region):
        # deal cost
        cost = float(0)
        if region in data:
            if self.inner in data[region]:
                for key, value in data[region][self.inner].items():
                    if "Networking Cloud Armor Policy" in key:
                        cost += float(value)
                    if "Networking Cloud Armor Rule" in key:
                        cost += float(value)
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# GCP Cloud Armor  cost
# e.g. Armor Requests


class DealArmorCost:
    def __init__(self, provider, date_str):
        self.service = "WAF"
        self.inner = "Networking"
        self.inner_service = "Cloud Armor"
        self.provider = provider
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data, region):
        # deal cost
        cost = float(0)
        if region in data:
            if self.inner in data[region]:
                for key, value in data[region][self.inner].items():
                    if "Networking Cloud Armor Requests" in key:
                        cost += float(value)
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)


# GCP Data Transfer  cost
# Data Transfer is a composite cost that is billed as the in/out spend for each service.
class DealDataTransferCost:
    def __init__(self, provider, date_str):
        self.service = "Data Transfer"
        self.inner = "Networking"
        self.inner_service = "Data Transfer"
        self.provider = provider
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data, region):
        # deal cost
        cost = float(0)
        if region in data:
            for values in data[region].values():
                for key, value in values.items():
                    if "Network Egress" in key:
                        cost += float(value)
                    elif "Network Ingress" in key:
                        cost += float(value)
                    elif "Network Google" in key:
                        cost += float(value)
                    elif "Network Inter Region" in key:
                        cost += float(value)
                    elif "Network Inter Zone" in key:
                        cost += float(value)
                    elif "Network Intra Zone" in key:
                        cost += float(value)
                    elif "Network Internet" in key:
                        cost += float(value)
                    elif "Network HTTP" in key:
                        cost += float(value)
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# Artifact Registry


class DealArtifactRegistryCost:
    def __init__(self, provider, date_str):
        self.service = "Container Registry"
        self.inner_service = "Artifact Registry"
        self.provider = provider
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data, region):
        # deal  cost
        cost = float(0)
        if region in data:
            if self.inner_service in data[region]:
                for key, value in data[region][self.inner_service].items():
                    cost += float(value)
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# gcp Persistent Disk  cost


class DealPDCost:
    def __init__(self, provider, date_str):
        self.service = "EBS"
        self.inner = "Compute Engine"
        self.inner_service = "Persistent Disk"
        self.provider = provider
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data, region):
        # deal cost
        cost = float(0)
        if region in data:
            if self.inner in data[region]:
                for key, value in data[region][self.inner].items():
                    if "PD Capacity" in key:
                        cost += float(value)
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# nat
# NatGateway  fixed cost


class DealNatGatewayFixedCost:
    def __init__(self, provider, date_str):
        self.service = "NatGateway"
        self.inner = "Networking"
        self.inner_service = "Networking Cloud Nat Gateway"
        self.provider = provider
        self.fixed_cost = True
        self.date = date_str

    def deal(self, data, region):
        # deal cost
        cost = float(0)
        if region in data:
            if self.inner in data[region]:
                for key, value in data[region][self.inner].items():
                    if "Nat Gateway Uptime" in key:
                        cost += float(value)
                    if "NAT IP Usage" in key:
                        cost += float(value)
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# NatGateway  cost


class DealNatGatewayCost:
    def __init__(self, provider, date_str):
        self.service = "NatGateway"
        self.inner = "Networking"
        self.inner_service = "Networking Cloud Nat Gateway"
        self.provider = provider
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data, region):
        # deal cost
        cost = float(0)
        if region in data:
            if self.inner in data[region]:
                for key, value in data[region][self.inner].items():
                    if "Nat Data Processing" in key:
                        cost += float(value)
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)


# Compute Engine
class DealCECost:
    def __init__(self, provider, date_str):
        self.service = "Elastic Compute"
        self.inner_service = "Compute Engine"
        self.provider = provider
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data, region):
        # deal cost
        cost = float(0)
        if region in data:
            if self.inner_service in data[region]:
                for key, value in data[region][self.inner_service].items():
                    if "Instance" in key:
                        cost += float(value)
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# gke


class DealGKSCost:
    def __init__(self, provider, date_str):
        self.service = "Kubernetes Service"
        self.inner_service = "Kubernetes Engine"
        self.provider = provider
        self.fixed_cost = True
        self.date = date_str

    def deal(self, data, region):
        # deal cost
        cost = float(0)
        if region in data:
            if self.inner_service in data[region]:
                for key, value in data[region][self.inner_service].items():
                    cost += float(value)
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)


# elb
class DealELBFixedCost:
    def __init__(self, provider, date_str):
        self.service = "Elastic Load Balancing"
        self.inner_old = "Compute Engine"
        self.inner_new = "Networking"  # after 2023.7 load balancer is moved to Networking
        self.inner_service = "Load Balancing"
        self.provider = provider
        self.fixed_cost = True
        self.date = date_str

    def deal(self, data, region):
        # deal cost
        cost = float(0)
        if region in data:
            if self.inner_old in data[region]:
                for key, value in data[region][self.inner_old].items():
                    if "Load Balancing: Global Forwarding" in key:
                        cost += float(value)
                    elif "Load Balancing: Forwarding Rule" in key:
                        cost += float(value)
            if self.inner_new in data[region]:
                for key, value in data[region][self.inner_new].items():
                    if "Load Balancer Forwarding Rule" in key:
                        cost += float(value)
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)


class DealELBCost:
    def __init__(self, provider, date_str):
        self.service = "Elastic Load Balancing"
        self.inner_service = "Load Balancing"
        self.provider = provider
        self.fixed_cost = False
        self.date = date_str

    def deal(self, data, region):
        # deal cost
        cost = float(0)
        if region in data:
            for values in data[region].values():
                for key, value in values.items():
                    if "Load Balancing HTTPS External Global Outbound Data Processing" in key:
                        cost += float(value)
                    elif "Load Balancing Network Passthrough" in key:
                        cost += float(value)
                    elif "Load Balancing Egress" in key:
                        cost += float(value)
                    elif "Load Balancing Ingress" in key:
                        cost += float(value)
                    elif "Load Balancing: Data Processing" in key:
                        cost += float(value)
                    elif "Load Balancer Inbound Data" in key:
                        cost += float(value)
                    elif "Load Balancer Outbound Data" in key:
                        cost += float(value)
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)