from common.common import CostDetail
from pprint import pprint


class AliCloudProcesser:
    def __init__(self, data, provider,regionmap,date_str):
        self.data = data
        self.provider = provider
        self.region_map = regionmap
        self.pre_task = [MergeCostByService(self.region_map)]
        self.date = date_str
        self.task = [DealOSSCost(self.provider, self.date),
                     DealACRFixedCost(self.provider, self.date),
                     DealWAFCost(self.provider, self.date),
                     DeaKMSCost(self.provider, self.date),
                     DealYunDiskCost(self.provider, self.date),
                     DealNatGatewayFixedCost(self.provider, self.date),
                     DealESCCost(self.provider, self.date),
                     DealACKCost(self.provider, self.date),
                     DealELBFixedCost(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


def mapRegion(region, region_map):
    # map region
    if region in region_map:
        return region_map[region]
    else:
        return None

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


# OSS
class DealOSSCost:
    def __init__(self, provider, date_str):
        self.service = "Simple Storage Service"
        self.inner_service = "Object Storage Service"
        self.inner ="oss"
        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 in data[region]:
                cost += float(data[region][self.inner])
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# Alicloud ACR fixed cost
class DealACRFixedCost:
    def __init__(self, provider, date_str):
        self.service = "Elastic Container Registry"
        self.inner_service = "Alibaba Cloud Container Registry"
        self.inner = "acr"
        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]:
               cost += float(data[region][self.inner])
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# Alicloud WAF cost
class DealWAFCost:
    def __init__(self, provider, date_str):
        self.service = "WAF"
        self.inner_service = "WAF"
        self.inner = "waf"
        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]:
                cost += float(data[region][self.inner])
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)


# AliCloud Data Transfer  cost
# now the bill not include data transfer cost like public network
# 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)

# KMS
class DeaKMSCost:
    def __init__(self, provider, date_str):
        self.service = "Key Management Service"
        self.inner_service = "Key Management Service"
        self.inner = "kms"
        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]:
                cost += float(data[region][self.inner])
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)


# alicloud yundisk  cost
class DealYunDiskCost:
    def __init__(self, provider, date_str):
        self.service = "EBS"
        self.inner = "yundisk"
        self.inner_service = "Yun 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]:
                cost += float(data[region][self.inner])
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# alicloud nat
# NatGateway  fixed cost
class DealNatGatewayFixedCost:
    def __init__(self, provider, date_str):
        self.service = "NatGateway"
        self.inner = "nat_gw"
        self.inner_service = "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]:
              cost += float(data[region][self.inner])
        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)


# AliCloud Elastic Compute Service cost
class DealESCCost:
    def __init__(self, provider, date_str):
        self.service = "Elastic Compute"
        self.inner_service = "Elastic Compute Service"
        self.inner = "ecs"
        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]:
                cost += float(data[region][self.inner])
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)

# alicloud ack
class DealACKCost:
    def __init__(self, provider, date_str):
        self.service = "Kubernetes Service"
        self.inner_service = "Kubernetes Service"
        self.inner = "csk"
        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]:
                cost += float(data[region][self.inner])
        return CostDetail(self.provider, region, self.service, self.inner_service, round(cost, 2), self.fixed_cost, self.date)


# alicloud SLB Cost
class DealELBFixedCost:
    def __init__(self, provider, date_str):
        self.service = "Elastic Load Balancing"
        self.inner = "slb"
        self.inner_ip ="eip"
        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 in data[region]:
                cost += float(data[region][self.inner])
             if self.inner_ip in data[region]:
                cost += float(data[region][self.inner_ip])
        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)