import pprint
from typing import List


class SystemSpecs:
    def __init__(self):
        pass

    @property
    def os(self):
        return self._os

    @os.setter
    def os(self, os):
        # List
        self._os = os

    @property
    def ramsize(self):
        return self._ramsize

    @ramsize.setter
    def ramsize(self, ramsize):
        # Int
        self._ramsize = ramsize

    @property
    def cpu(self):
        return self._cpu

    @cpu.setter
    def cpu(self):
        self._cpu = self.CPU()

    @property
    def opticaldrive(self):
        return self._opticaldrive

    @opticaldrive.setter
    def opticaldrive(self, opticaldrive):
        # String
        self._opticaldrive = opticaldrive

    @property
    def gpu(self):
        return self._gpu

    @gpu.setter
    def gpu(self):
        self._gpu = self.GPU()

    @property
    def hddspace(self):
        return self._hddspace

    @hddpspace.setter
    def hddspace(self, hddspace):
        # Int
        self.hddspace = hddspace

    @property
    def nic(self):
        return self._nic

    @nic.setter
    def nic(self, nic):
        # List
        self._nic = nic

    def to_dict(self):
        d = self.__dict__
        for value in self.cpu:
            d["cpu"][d["cpu"].index(value)] = value.to_dict()

        for value in self.gpu:
            d["gpu"][d["gpu"].index(value)] = value.to_dict()

        return d

    class CPU:
        def __init__(self):
            pass

        @property
        def frequency(self):
            return self._frequency

        @frequency.setter
        def frequency(self, frequency):
            # String
            self._frequency = frequency

        @property
        def unit(self):
            return self._unit

        @unit.setter
        def unit(self, unit):
            # String
            self._unit = unit

        @property
        def model(self):
            return self._model

        @model.setter
        def model(self, model):
            # List
            self._model = model

        def to_dict(self):
            return self.__dict__

    class GPU:
        def __init__(self):
            pass

        def manufacturer(self, manufacturer):
            # String
            self.manufacturer = manufacturer

        def model(self, model):
            # List
            self.model = model

        def transfertype(self, transfertype):
            # List
            self.transfertype = transfertype

        def memorysize(self, memorysize):
            # Int
            self.memorysize = memorysize

        def engine(self, engine):
            # String
            self.engine = engine

        def directx(self, directx):
            # String
            self.directx = directx

        def to_dict(self):
            return self.__dict__


class Rating:
    def __init__(self):
        pass

    def organ(self, organ):
        # String
        self.organ = organ

    def verdict(self, verdict):
        # String
        self.verdict = verdict

    def to_dict(self):
        d = self.__dict__
        return d


class Game:
    #def __init__(self, title, year, originaltitle=""):
    def __init__(self):
        self._title = ""
#        self._originaltitle = ""
#        self._year = ""
#        self._plot = ""
#        self._genre = ""
#        self._playermodes = ""
#        self._cdkey = ""
#        if originaltitle == "":
#            self.originaltitle = title
#        else:
#            self.originaltitle = originaltitle
#        self.year = year

    @property
    def title(self):
        return self._title

    @title.setter
    def title(self, title):
        self._title = title

    @property
    def originaltitle(self):
        return self._originaltitle

    @originaltitle.setter
    def originaltitle(self, originaltitle):
        if originaltitle == "":
            originaltitle = self._title
        self._originaltitle = originaltitle

    @property
    def year(self):
        return self._year

    @year.setter
    def year(self, year):
        self._year = year

    def example(self):
        self._title = "Battlefield 2142"
        self._year = 2006

    @property
    def plot(self):
        return self._plot

    @plot.setter
    def plot(self, plot):
        self._plot = plot

    @property
    def genre(self):
        return self._genre

    @genre.setter
    def genre(self, genre):
        self._genre = genre

    @property
    def playermodes(self):
        return self._playermodes

    @playermodes.setter
    def playermodes(self, playermodes):
        modes = ["Singleplayer",
                 "Online Multiplayer",
                 "LAN"]
        try:
            if isinstance(playermodes, list):
                for mode in playermodes:
                    assert mode in modes, (
                            "### Assert error: " + self.title +
                            ": playermode \"" + mode +
                            "\" not valid. Valid options are " + str(modes) +
                            ". Skipping.")
                    # if mode not in modes:
                    # raise Exception("playermode " + mode + " not valid")
                self._playermodes = playermodes
        except AssertionError as e:
            print(e)

    def artwork(self, artwork):
        # TODO add type, title, region, notes and filename
        pass

    def imagelist(self, imagelist):
        # TODO add type, name, titleD6
        pass

    @property
    def cdkey(self):
        return self._cdkey

    @cdkey.setter
    def cdkey(self, cdkey):
        # TODO add validation of sorts
        self._cdkey = cdkey

    def documents(self, documents):
        # TODO add type and path. Also validation
        pass

    @property
    def linuxinstructions(self):
        return self._linuxinstructions

    @linuxinstructions.setter
    def linuxinstructions(self, linuxinstructions):
        self._linuxinstructions = linuxinstructions

    @property
    def systemrequirements(self):
        return self._systemrequirements

    @systemrequirements.setter
    def systemrequirements(self, specs):
        self._systemrequirements = SystemSpecs()

    @property
    def recommendedspecs(self):
        return self._recommendedspecs

    @recommendedspecs.setter
    def recommendedspecs(self, specs):
        self._recommendedspecs = SystemSpecs()

    @property
    def collab(self):
        return self._collab

    @collab.setter
    def collab(self, collab):
        self._collab = collab

    @property
    def developer(self):
        return self._developer

    @developer.setter
    def developer(self, developer):
        # String
        self._developer = developer

    @property
    def credit(self):
        return self._credit

    @credit.setter
    def credit(self, credit):
        try:
            if not isinstance(credit, list):
                raise TypeError
            self.credit = credit
        except TypeError:
            print("### Type error: " + self.title + ": credit is not a list")

    @property
    def rating(self):
        return self._rating

    @rating.setter
    def rating(self):
        self._rating = Rating()

    def to_dict(self):
        j = self.__dict__
        try:
            j["systemrequirements"] = self.systemrequirements.to_dict()
        except AttributeError:
            print("## " + self.title +
                  ": no systemrequirements found, skipping")
        try:
            j["recommendedspecs"] = self.recommendedspecs.to_dict()
        except AttributeError:
            print("## " + self.title +
                  ": no recommendedspecs found, skipping")
        try:
            j["rating"] = self.rating.to_dict()
        except AttributeError:
            print("## " + self.title +
                  ": no rating found, skipping")

        return j


def example():
    # testdata object
    g1 = Game("Battlefield 2142", 2006)
    g1.plot("Framtidens krig\n\nMedan en förödande istid tömmer jordens " +
            "resurser utkämpar två koalitioner ett desperat krig om det " +
            "enda som spelar någon roll - överlevnad.\n\n* Från skaparna" +
            " av den prisbelönta spelserien Battlefield\n* Krossa " +
            "motståndarens Titan i det helt nya, målbaserade Titan-" +
            "spelläget\n* Härska på slagfältet ned högteknologiska " +
            "fordon och vapen, som svävarstridsvagnar och EMP-granater\n* " +
            "Kämpa dig till titeln som överbefälhavare med belöningar i " +
            "realtid och lås upp saker som kanonrobotar och flyttbara " +
            "Spawn-punkter\n* Anpassa din karaktär så att den passar din " +
            "spelstil")
    g1.genre(["RPG", "FPS"])
    g1.playermodes(["Singleplayer", "Online Multiplayer", "LAN"])
    g1.cdkey("H98G-DW8M-USH8-VPL8-L265")
    g1req = SystemSpecs()
    g1req.os(["Windows XP"])
    g1req.ramsize(536870912)
    g1reqcpu = SystemSpecs().CPU()
    g1reqcpu.frequency("1.7")
    g1reqcpu.unit("GHz")
    g1reqcpu.model(["Intel Pentium 4", "AMD Athlon"])
    g1req.cpu = [g1reqcpu]
    g1reqgpu1 = SystemSpecs().GPU()
    g1reqgpu1.manufacturer("NVIDIA")
    g1reqgpu1.model(["GeForce 5800"])
    g1reqgpu1.transfertype(["AGP", "PCIe"])
    g1reqgpu1.memorysize(134217728)
    g1reqgpu1.directx("DirectX 9.0c")
    g1reqgpu2 = SystemSpecs().GPU()
    g1reqgpu2.manufacturer("ATI")
    g1reqgpu2.model(["Radeon 9500"])
    g1reqgpu2.transfertype(["AGP", "PCIe"])
    g1reqgpu2.memorysize(134217728)
    g1reqgpu2.directx("DirectX 9.0c")
    g1req.gpu = [g1reqgpu1, g1reqgpu2]
    g1req.opticaldrive("DVD 8x")
    g1req.hddspace(2362232013)
    g1req.nic(["128kbps"])
    g1.systemrequirements = g1req
    g1.developer("dice")
    g1.credit(["EA", "BINK Video", "SoundBlaster X-Fi", "gamespy"])
    g1rating = Rating()
    g1rating.organ("PEGI")
    g1rating.verdict("16+")
    g1.rating = g1rating

    myjson = g1.to_dict()
    pprint.pp(myjson)


#example()