# Copyright (c) 2018 The Android Open Source Project
# Copyright (c) 2018 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from copy import copy

from .common.codegen import CodeGen
from .common.vulkantypes import \
        VulkanAPI, makeVulkanTypeSimple, iterateVulkanType, VulkanTypeIterator

from .wrapperdefs import VulkanWrapperGenerator
from .wrapperdefs import EQUALITY_VAR_NAMES
from .wrapperdefs import EQUALITY_ON_FAIL_VAR
from .wrapperdefs import EQUALITY_ON_FAIL_VAR_TYPE
from .wrapperdefs import EQUALITY_RET_TYPE
from .wrapperdefs import API_PREFIX_EQUALITY
from .wrapperdefs import STRUCT_EXTENSION_PARAM, STRUCT_EXTENSION_PARAM2

class VulkanEqualityCodegen(VulkanTypeIterator):

    def __init__(self, cgen, inputVars, onFailCompareVar, prefix):
        self.cgen = cgen
        self.inputVars = inputVars
        self.onFailCompareVar = onFailCompareVar
        self.prefix = prefix

        def makeAccess(varName, asPtr = True):
            return lambda t: self.cgen.generalAccess(t, parentVarName = varName, asPtr = asPtr)

        def makeLengthAccess(varName):
            return lambda t: self.cgen.generalLengthAccess(t, parentVarName = varName)

        def makeLengthAccessGuard(varName):
            return lambda t: self.cgen.generalLengthAccessGuard(t, parentVarName=varName)

        self.exprAccessorLhs = makeAccess(self.inputVars[0])
        self.exprAccessorRhs = makeAccess(self.inputVars[1])

        self.exprAccessorValueLhs = makeAccess(self.inputVars[0], asPtr = False)
        self.exprAccessorValueRhs = makeAccess(self.inputVars[1], asPtr = False)

        self.lenAccessorLhs = makeLengthAccess(self.inputVars[0])
        self.lenAccessorRhs = makeLengthAccess(self.inputVars[1])

        self.lenAccessGuardLhs = makeLengthAccessGuard(self.inputVars[0])
        self.lenAccessGuardRhs = makeLengthAccessGuard(self.inputVars[1])

        self.checked = False

    def getTypeForCompare(self, vulkanType):
        res = copy(vulkanType)

        if not vulkanType.accessibleAsPointer():
            res = res.getForAddressAccess()

        if vulkanType.staticArrExpr:
            res = res.getForAddressAccess()

        return res

    def makeCastExpr(self, vulkanType):
        return "(%s)" % (
            self.cgen.makeCTypeDecl(vulkanType, useParamName=False))

    def makeEqualExpr(self, lhs, rhs):
        return "(%s) == (%s)" % (lhs, rhs)

    def makeEqualBufExpr(self, lhs, rhs, size):
        return "(memcmp(%s, %s, %s) == 0)" % (lhs, rhs, size)

    def makeEqualStringExpr(self, lhs, rhs):
        return "(strcmp(%s, %s) == 0)" % (lhs, rhs)

    def makeBothNotNullExpr(self, lhs, rhs):
        return "(%s) && (%s)" % (lhs, rhs)

    def makeBothNullExpr(self, lhs, rhs):
        return "!(%s) && !(%s)" % (lhs, rhs)

    def compareWithConsequence(self, compareExpr, vulkanType, errMsg=""):
        self.cgen.stmt("if (!(%s)) { %s(\"%s (Error: %s)\"); }" %
                       (compareExpr, self.onFailCompareVar,
                        self.exprAccessorValueLhs(vulkanType), errMsg))

    def onCheck(self, vulkanType):

        self.checked = True

        accessLhs = self.exprAccessorLhs(vulkanType)
        accessRhs = self.exprAccessorRhs(vulkanType)

        bothNull = self.makeBothNullExpr(accessLhs, accessRhs)
        bothNotNull = self.makeBothNotNullExpr(accessLhs, accessRhs)
        nullMatchExpr = "(%s) || (%s)" % (bothNull, bothNotNull)

        self.compareWithConsequence( \
            nullMatchExpr,
            vulkanType,
            "Mismatch in optional field")

        skipStreamInternal = vulkanType.typeName == "void"

        if skipStreamInternal:
            return

        self.cgen.beginIf("%s && %s" % (accessLhs, accessRhs))

    def endCheck(self, vulkanType):

        skipStreamInternal = vulkanType.typeName == "void"
        if skipStreamInternal:
            return

        if self.checked:
            self.cgen.endIf()
            self.checked = False

    def onCompoundType(self, vulkanType):
        accessLhs = self.exprAccessorLhs(vulkanType)
        accessRhs = self.exprAccessorRhs(vulkanType)

        lenAccessLhs = self.lenAccessorLhs(vulkanType)
        lenAccessRhs = self.lenAccessorRhs(vulkanType)

        lenAccessGuardLhs = self.lenAccessGuardLhs(vulkanType)
        lenAccessGuardRhs = self.lenAccessGuardRhs(vulkanType)

        needNullCheck = vulkanType.pointerIndirectionLevels > 0

        if needNullCheck:
            bothNotNullExpr = self.makeBothNotNullExpr(accessLhs, accessRhs)
            self.cgen.beginIf(bothNotNullExpr)

        if lenAccessLhs is not None:
            equalLenExpr = self.makeEqualExpr(lenAccessLhs, lenAccessRhs)

            self.compareWithConsequence( \
                equalLenExpr,
                vulkanType, "Lengths not equal")

            loopVar = "i"
            accessLhs = "%s + %s" % (accessLhs, loopVar)
            accessRhs = "%s + %s" % (accessRhs, loopVar)
            forInit = "uint32_t %s = 0" % loopVar
            forCond = "%s < (uint32_t)%s" % (loopVar, lenAccessLhs)
            forIncr = "++%s" % loopVar

            if needNullCheck:
                self.cgen.beginIf(equalLenExpr)

            if lenAccessGuardLhs is not None:
                self.cgen.beginIf(lenAccessGuardLhs)

            self.cgen.beginFor(forInit, forCond, forIncr)

        self.cgen.funcCall(None, self.prefix + vulkanType.typeName,
                           [accessLhs, accessRhs, self.onFailCompareVar])

        if lenAccessLhs is not None:
            self.cgen.endFor()
            if lenAccessGuardLhs is not None:
                self.cgen.endIf()
            if needNullCheck:
                self.cgen.endIf()

        if needNullCheck:
            self.cgen.endIf()

    def onString(self, vulkanType):
        accessLhs = self.exprAccessorLhs(vulkanType)
        accessRhs = self.exprAccessorRhs(vulkanType)

        bothNullExpr = self.makeBothNullExpr(accessLhs, accessRhs)
        bothNotNullExpr = self.makeBothNotNullExpr(accessLhs, accessRhs)
        nullMatchExpr = "(%s) || (%s)" % (bothNullExpr, bothNotNullExpr)

        self.compareWithConsequence( \
            nullMatchExpr,
            vulkanType,
            "Mismatch in string pointer nullness")

        self.cgen.beginIf(bothNotNullExpr)

        self.compareWithConsequence(
            self.makeEqualStringExpr(accessLhs, accessRhs),
            vulkanType, "Unequal strings")

        self.cgen.endIf()

    def onStringArray(self, vulkanType):
        accessLhs = self.exprAccessorLhs(vulkanType)
        accessRhs = self.exprAccessorRhs(vulkanType)

        lenAccessLhs = self.lenAccessorLhs(vulkanType)
        lenAccessRhs = self.lenAccessorRhs(vulkanType)

        lenAccessGuardLhs = self.lenAccessGuardLhs(vulkanType)
        lenAccessGuardRhs = self.lenAccessGuardRhs(vulkanType)

        bothNullExpr = self.makeBothNullExpr(accessLhs, accessRhs)
        bothNotNullExpr = self.makeBothNotNullExpr(accessLhs, accessRhs)
        nullMatchExpr = "(%s) || (%s)" % (bothNullExpr, bothNotNullExpr)

        self.compareWithConsequence( \
            nullMatchExpr,
            vulkanType,
            "Mismatch in string array pointer nullness")

        equalLenExpr = self.makeEqualExpr(lenAccessLhs, lenAccessRhs)

        self.compareWithConsequence( \
            equalLenExpr,
            vulkanType, "Lengths not equal in string array")

        self.compareWithConsequence( \
            equalLenExpr,
            vulkanType, "Lengths not equal in string array")

        self.cgen.beginIf("%s && %s" % (equalLenExpr, bothNotNullExpr))

        loopVar = "i"
        accessLhs = "*(%s + %s)" % (accessLhs, loopVar)
        accessRhs = "*(%s + %s)" % (accessRhs, loopVar)
        forInit = "uint32_t %s = 0" % loopVar
        forCond = "%s < (uint32_t)%s" % (loopVar, lenAccessLhs)
        forIncr = "++%s" % loopVar

        if lenAccessGuardLhs is not None:
            self.cgen.beginIf(lenAccessGuardLhs)

        self.cgen.beginFor(forInit, forCond, forIncr)

        self.compareWithConsequence(
            self.makeEqualStringExpr(accessLhs, accessRhs),
            vulkanType, "Unequal string in string array")

        self.cgen.endFor()

        if lenAccessGuardLhs is not None:
            self.cgen.endIf()

        self.cgen.endIf()

    def onStaticArr(self, vulkanType):
        accessLhs = self.exprAccessorLhs(vulkanType)
        accessRhs = self.exprAccessorRhs(vulkanType)

        lenAccessLhs = self.lenAccessorLhs(vulkanType)

        finalLenExpr = "%s * %s" % (lenAccessLhs,
                                    self.cgen.sizeofExpr(vulkanType))

        self.compareWithConsequence(
            self.makeEqualBufExpr(accessLhs, accessRhs, finalLenExpr),
            vulkanType, "Unequal static array")

    def onStructExtension(self, vulkanType):
        lhs = self.exprAccessorLhs(vulkanType)
        rhs = self.exprAccessorRhs(vulkanType)

        self.cgen.beginIf(lhs)
        self.cgen.funcCall(None, self.prefix + "extension_struct",
                           [lhs, rhs, self.onFailCompareVar])
        self.cgen.endIf()

    def onPointer(self, vulkanType):
        accessLhs = self.exprAccessorLhs(vulkanType)
        accessRhs = self.exprAccessorRhs(vulkanType)

        skipStreamInternal = vulkanType.typeName == "void"
        if skipStreamInternal:
            return

        lenAccessLhs = self.lenAccessorLhs(vulkanType)
        lenAccessRhs = self.lenAccessorRhs(vulkanType)

        if lenAccessLhs is not None:
            self.compareWithConsequence( \
                self.makeEqualExpr(lenAccessLhs, lenAccessRhs),
                vulkanType, "Lengths not equal")

            finalLenExpr = "%s * %s" % (lenAccessLhs,
                                        self.cgen.sizeofExpr(
                                            vulkanType.getForValueAccess()))
        else:
            finalLenExpr = self.cgen.sizeofExpr(vulkanType.getForValueAccess())

        self.compareWithConsequence(
            self.makeEqualBufExpr(accessLhs, accessRhs, finalLenExpr),
            vulkanType, "Unequal dyn array")

    def onValue(self, vulkanType):
        accessLhs = self.exprAccessorValueLhs(vulkanType)
        accessRhs = self.exprAccessorValueRhs(vulkanType)
        self.compareWithConsequence(
            self.makeEqualExpr(accessLhs, accessRhs), vulkanType,
            "Value not equal")


class VulkanTesting(VulkanWrapperGenerator):

    def __init__(self, module, typeInfo):
        VulkanWrapperGenerator.__init__(self, module, typeInfo)

        self.codegen = CodeGen()

        self.equalityCodegen = \
            VulkanEqualityCodegen(
                None,
                EQUALITY_VAR_NAMES,
                EQUALITY_ON_FAIL_VAR,
                API_PREFIX_EQUALITY)

        self.knownDefs = {}

        self.extensionTestingPrototype = \
            VulkanAPI(API_PREFIX_EQUALITY + "extension_struct",
                      EQUALITY_RET_TYPE,
                      [STRUCT_EXTENSION_PARAM,
                       STRUCT_EXTENSION_PARAM2,
                       EQUALITY_ON_FAIL_VAR_TYPE])

    def onBegin(self,):
        VulkanWrapperGenerator.onBegin(self)
        self.module.appendImpl(self.codegen.makeFuncDecl(
            self.extensionTestingPrototype))

    def onGenType(self, typeXml, name, alias):
        VulkanWrapperGenerator.onGenType(self, typeXml, name, alias)

        if name in self.knownDefs:
            return

        category = self.typeInfo.categoryOf(name)

        if category in ["struct", "union"] and alias:
            self.module.appendHeader(
                self.codegen.makeFuncAlias(API_PREFIX_EQUALITY + name,
                                           API_PREFIX_EQUALITY + alias))

        if category in ["struct", "union"] and not alias:

            structInfo = self.typeInfo.structs[name]

            typeFromName = \
                lambda varname: makeVulkanTypeSimple(True, name, 1, varname)

            compareParams = \
                list(map(typeFromName, EQUALITY_VAR_NAMES)) + \
                [EQUALITY_ON_FAIL_VAR_TYPE]

            comparePrototype = \
                VulkanAPI(API_PREFIX_EQUALITY + name,
                          EQUALITY_RET_TYPE,
                          compareParams)

            def structCompareDef(cgen):
                self.equalityCodegen.cgen = cgen
                for member in structInfo.members:
                    iterateVulkanType(self.typeInfo, member,
                                      self.equalityCodegen)

            self.module.appendHeader(
                self.codegen.makeFuncDecl(comparePrototype))
            self.module.appendImpl(
                self.codegen.makeFuncImpl(comparePrototype, structCompareDef))

    def onGenCmd(self, cmdinfo, name, alias):
        VulkanWrapperGenerator.onGenCmd(self, cmdinfo, name, alias)

    def onEnd(self,):
        VulkanWrapperGenerator.onEnd(self)

        def forEachExtensionCompare(ext, castedAccess, cgen):
            cgen.funcCall(None, API_PREFIX_EQUALITY + ext.name,
                          [castedAccess,
                           cgen.makeReinterpretCast(
                               STRUCT_EXTENSION_PARAM2.paramName, ext.name),
                           EQUALITY_ON_FAIL_VAR])

        self.module.appendImpl(
            self.codegen.makeFuncImpl(
                self.extensionTestingPrototype,
                lambda cgen: self.emitForEachStructExtension(
                    cgen,
                    EQUALITY_RET_TYPE,
                    STRUCT_EXTENSION_PARAM,
                    forEachExtensionCompare)))