import ui
import snd
import shop
import mouseModule
import player
import chr
import net
import uiCommon
import locale
import chat
import item

g_isBuildingPrivateShop = FALSE

g_itemPriceDict={}

def Clear():
    global g_itemPriceDict
    global g_isBuildingPrivateShop
    g_itemPriceDict={}
    g_isBuildingPrivateShop = FALSE

def IsPrivateShopItemPriceList():
    global g_itemPriceDict
    if g_itemPriceDict:
        return TRUE
    else:
        return FALSE

def IsBuildingPrivateShop():
    global g_isBuildingPrivateShop
    if player.IsOpenPrivateShop() or g_isBuildingPrivateShop:
        return TRUE
    else:
        return FALSE

def SetPrivateShopItemPrice(itemVNum, itemPrice):
    global g_itemPriceDict
    g_itemPriceDict[int(itemVNum)]=itemPrice

def GetPrivateShopItemPrice(itemVNum):
    try:
        global g_itemPriceDict
        return g_itemPriceDict[itemVNum]
    except KeyError:
        return 0


class PrivateShopAdvertisementBoard(ui.ThinBoard):
    def __init__(self):
        ui.ThinBoard.__init__(self, "UI_BOTTOM")

        self.vid = None

        self.__MakeTextLine()

    def __del__(self):
        ui.ThinBoard.__del__(self)

    def __MakeTextLine(self):
        self.textLine = ui.TextLine()
        self.textLine.SetParent(self)
        self.textLine.SetWindowHorizontalAlignCenter()
        self.textLine.SetWindowVerticalAlignCenter()
        self.textLine.SetHorizontalAlignCenter()
        self.textLine.SetVerticalAlignCenter()
        self.textLine.Show()

    def Open(self, vid, text):

        self.vid = vid

        self.textLine.SetText(text)
        self.textLine.UpdateRect()

        self.SetSize(len(text)*6 + 10*2, 20)
        self.Show()

    def OnMouseLeftButtonUp(self):

        if not self.vid:
            return

        net.SendOnClickPacket(self.vid)

        return TRUE

    def OnUpdate(self):
        if not self.vid:
            return

        x, y = chr.GetProjectPosition(self.vid, 220)
        self.SetPosition(x - self.GetWidth()/2, y - self.GetHeight()/2)


class PrivateShopBuilder(ui.ScriptWindow):

    def __init__(self):
        #print "NEW MAKE_PRIVATE_SHOP_WINDOW ----------------------------------------------------------------"
        ui.ScriptWindow.__init__(self)

        self.__LoadWindow()
        self.itemStock = {}
        self.tooltipItem = None
        self.priceInputBoard = None
        self.title = ""

    def __del__(self):
        #print "------------------------------------------------------------- DELETE MAKE_PRIVATE_SHOP_WINDOW"
        ui.ScriptWindow.__del__(self)

    def __LoadWindow(self):
        try:
            pyScrLoader = ui.PythonScriptLoader()
            pyScrLoader.LoadScriptFile(self, "UIScript/PrivateShopBuilder.py")
        except:
            import exception
            exception.Abort("PrivateShopBuilderWindow.LoadWindow.LoadObject")

        try:
            GetObject = self.GetChild
            self.nameLine = GetObject("NameLine")
            self.itemSlot = GetObject("ItemSlot")
            self.btnOk = GetObject("OkButton")
            self.btnClose = GetObject("CloseButton")
            self.titleBar = GetObject("TitleBar")
        except:
            import exception
            exception.Abort("PrivateShopBuilderWindow.LoadWindow.BindObject")

        self.btnOk.SetEvent(ui.__mem_func__(self.OnOk))
        self.btnClose.SetEvent(ui.__mem_func__(self.OnClose))
        self.titleBar.SetCloseEvent(ui.__mem_func__(self.OnClose))

        self.itemSlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.OnSelectEmptySlot))
        self.itemSlot.SetSelectItemSlotEvent(ui.__mem_func__(self.OnSelectItemSlot))
        self.itemSlot.SetOverInItemEvent(ui.__mem_func__(self.OnOverInItem))
        self.itemSlot.SetOverOutItemEvent(ui.__mem_func__(self.OnOverOutItem))

    def Destroy(self):
        self.ClearDictionary()

        self.nameLine = None
        self.itemSlot = None
        self.btnOk = None
        self.btnClose = None
        self.titleBar = None
        self.priceInputBoard = None

    def Open(self, title):

        self.title = title

        if len(title) > 25:
            title = title[:22] + "..."

        self.itemStock = {}
        shop.ClearPrivateShopStock()
        self.nameLine.SetText(title)
        self.SetCenterPosition()
        self.Refresh()
        self.Show()

        global g_isBuildingPrivateShop
        g_isBuildingPrivateShop = TRUE

    def Close(self):
        global g_isBuildingPrivateShop
        g_isBuildingPrivateShop = FALSE

        self.title = ""
        self.itemStock = {}
        shop.ClearPrivateShopStock()
        self.Hide()

    def SetItemToolTip(self, tooltipItem):
        self.tooltipItem = tooltipItem

    def Refresh(self):
        getitemVNum=player.GetItemIndex
        getItemCount=player.GetItemCount
        setitemVNum=self.itemSlot.SetItemSlot
        delItem=self.itemSlot.ClearSlot

        for i in xrange(shop.SHOP_SLOT_COUNT):

            if not self.itemStock.has_key(i):
                delItem(i)
                continue

            pos = self.itemStock[i]

            itemCount = getItemCount(pos)
            if itemCount <= 1:
                itemCount = 0
            setitemVNum(i, getitemVNum(pos), itemCount)

        self.itemSlot.RefreshSlot()

    def OnSelectEmptySlot(self, selectedSlotPos):

        isAttached = mouseModule.mouseController.isAttached()
        if isAttached:
            attachedSlotType = mouseModule.mouseController.GetAttachedType()
            attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
            mouseModule.mouseController.DeattachObject()

            if player.SLOT_TYPE_INVENTORY != attachedSlotType:
                return

            itemVNum = player.GetItemIndex(attachedSlotPos)
            item.SelectItem(itemVNum)

            if item.IsAntiFlag(item.ITEM_ANTIFLAG_GIVE) or item.IsAntiFlag(item.ITEM_ANTIFLAG_MYSHOP):
                chat.AppendChat(chat.CHAT_TYPE_INFO, locale.PRIVATE_SHOP_CANNOT_SELL_ITEM)
                return

            priceInputBoard = uiCommon.MoneyInputDialog()
            priceInputBoard.SetTitle(locale.PRIVATE_SHOP_INPUT_PRICE_DIALOG_TITLE)
            priceInputBoard.SetAcceptEvent(ui.__mem_func__(self.AcceptInputPrice))
            priceInputBoard.SetCancelEvent(ui.__mem_func__(self.CancelInputPrice))
            priceInputBoard.Open()

            itemPrice=GetPrivateShopItemPrice(itemVNum)

            if itemPrice>0:
                priceInputBoard.SetValue(itemPrice)

            self.priceInputBoard = priceInputBoard
            self.priceInputBoard.itemVNum = itemVNum
            self.priceInputBoard.sourceSlotPos = attachedSlotPos
            self.priceInputBoard.targetSlotPos = selectedSlotPos

    def OnSelectItemSlot(self, selectedSlotPos):

        isAttached = mouseModule.mouseController.isAttached()
        if isAttached:
            snd.PlaySound("sound/ui/loginfail.wav")
            mouseModule.mouseController.DeattachObject()

        else:
            if not selectedSlotPos in self.itemStock:
                return

            inventoryPos = self.itemStock[selectedSlotPos]
            shop.DelPrivateShopItemStock(inventoryPos)
            snd.PlaySound("sound/ui/drop.wav")

            del self.itemStock[selectedSlotPos]

            self.Refresh()

    def AcceptInputPrice(self):

        if not self.priceInputBoard:
            return TRUE

        text = self.priceInputBoard.GetText()

        if not text:
            return TRUE

        if not text.isdigit():
            return TRUE

        if int(text) <= 0:
            return TRUE

        sourceSlotPos = self.priceInputBoard.sourceSlotPos
        targetSlotPos = self.priceInputBoard.targetSlotPos

        for privatePos, inventorySlotPos in self.itemStock.items():
            if inventorySlotPos == sourceSlotPos:
                shop.DelPrivateShopItemStock(targetSlotPos)
                del self.itemStock[privatePos]

        price = int(self.priceInputBoard.GetText())

        if IsPrivateShopItemPriceList():
            SetPrivateShopItemPrice(self.priceInputBoard.itemVNum, price)

        shop.AddPrivateShopItemStock(sourceSlotPos, targetSlotPos, price)
        self.itemStock[targetSlotPos] = sourceSlotPos
        snd.PlaySound("sound/ui/drop.wav")

        self.Refresh()

        #####

        self.priceInputBoard = None
        return TRUE

    def CancelInputPrice(self):
        self.priceInputBoard = None
        return TRUE

    def OnOk(self):

        if not self.title:
            return

        if 0 == len(self.itemStock):
            return

        shop.BuildPrivateShop(self.title)
        self.Close()

    def OnClose(self):
        self.Close()

    def OnPressEscapeKey(self):
        self.Close()
        return TRUE

    def OnOverInItem(self, slotIndex):

        if self.tooltipItem:
            if self.itemStock.has_key(slotIndex):
                self.tooltipItem.SetPrivateShopBuilderItem(self.itemStock[slotIndex], slotIndex)

    def OnOverOutItem(self):

        if self.tooltipItem:
            self.tooltipItem.HideToolTip()