// +build !windows

package ole

import (
        "time"
        "unsafe"
)

// coInitialize initializes COM library on current thread.
//
// MSDN documentation suggests that this function should not be called. Call
// CoInitializeEx() instead. The reason has to do with threading and this
// function is only for single-threaded apartments.
//
// That said, most users of the library have gotten away with just this
// function. If you are experiencing threading issues, then use
// CoInitializeEx().
func coInitialize() error {
        return NewError(E_NOTIMPL)
}

// coInitializeEx initializes COM library with concurrency model.
func coInitializeEx(coinit uint32) error {
        return NewError(E_NOTIMPL)
}

// CoInitialize initializes COM library on current thread.
//
// MSDN documentation suggests that this function should not be called. Call
// CoInitializeEx() instead. The reason has to do with threading and this
// function is only for single-threaded apartments.
//
// That said, most users of the library have gotten away with just this
// function. If you are experiencing threading issues, then use
// CoInitializeEx().
func CoInitialize(p uintptr) error {
        return NewError(E_NOTIMPL)
}

// CoInitializeEx initializes COM library with concurrency model.
func CoInitializeEx(p uintptr, coinit uint32) error {
        return NewError(E_NOTIMPL)
}

// CoUninitialize uninitializes COM Library.
func CoUninitialize() {}

// CoTaskMemFree frees memory pointer.
func CoTaskMemFree(memptr uintptr) {}

// CLSIDFromProgID retrieves Class Identifier with the given Program Identifier.
//
// The Programmatic Identifier must be registered, because it will be looked up
// in the Windows Registry. The registry entry has the following keys: CLSID,
// Insertable, Protocol and Shell
// (https://msdn.microsoft.com/en-us/library/dd542719(v=vs.85).aspx).
//
// programID identifies the class id with less precision and is not guaranteed
// to be unique. These are usually found in the registry under
// HKEY_LOCAL_MACHINE\SOFTWARE\Classes, usually with the format of
// "Program.Component.Version" with version being optional.
//
// CLSIDFromProgID in Windows API.
func CLSIDFromProgID(progId string) (*GUID, error) {
        return nil, NewError(E_NOTIMPL)
}

// CLSIDFromString retrieves Class ID from string representation.
//
// This is technically the string version of the GUID and will convert the
// string to object.
//
// CLSIDFromString in Windows API.
func CLSIDFromString(str string) (*GUID, error) {
        return nil, NewError(E_NOTIMPL)
}

// StringFromCLSID returns GUID formated string from GUID object.
func StringFromCLSID(clsid *GUID) (string, error) {
        return "", NewError(E_NOTIMPL)
}

// IIDFromString returns GUID from program ID.
func IIDFromString(progId string) (*GUID, error) {
        return nil, NewError(E_NOTIMPL)
}

// StringFromIID returns GUID formatted string from GUID object.
func StringFromIID(iid *GUID) (string, error) {
        return "", NewError(E_NOTIMPL)
}

// CreateInstance of single uninitialized object with GUID.
func CreateInstance(clsid *GUID, iid *GUID) (*IUnknown, error) {
        return nil, NewError(E_NOTIMPL)
}

// GetActiveObject retrieves pointer to active object.
func GetActiveObject(clsid *GUID, iid *GUID) (*IUnknown, error) {
        return nil, NewError(E_NOTIMPL)
}

// VariantInit initializes variant.
func VariantInit(v *VARIANT) error {
        return NewError(E_NOTIMPL)
}

// VariantClear clears value in Variant settings to VT_EMPTY.
func VariantClear(v *VARIANT) error {
        return NewError(E_NOTIMPL)
}

// SysAllocString allocates memory for string and copies string into memory.
func SysAllocString(v string) *int16 {
        u := int16(0)
        return &u
}

// SysAllocStringLen copies up to length of given string returning pointer.
func SysAllocStringLen(v string) *int16 {
        u := int16(0)
        return &u
}

// SysFreeString frees string system memory. This must be called with SysAllocString.
func SysFreeString(v *int16) error {
        return NewError(E_NOTIMPL)
}

// SysStringLen is the length of the system allocated string.
func SysStringLen(v *int16) uint32 {
        return uint32(0)
}

// CreateStdDispatch provides default IDispatch implementation for IUnknown.
//
// This handles default IDispatch implementation for objects. It haves a few
// limitations with only supporting one language. It will also only return
// default exception codes.
func CreateStdDispatch(unk *IUnknown, v uintptr, ptinfo *IUnknown) (*IDispatch, error) {
        return nil, NewError(E_NOTIMPL)
}

// CreateDispTypeInfo provides default ITypeInfo implementation for IDispatch.
//
// This will not handle the full implementation of the interface.
func CreateDispTypeInfo(idata *INTERFACEDATA) (*IUnknown, error) {
        return nil, NewError(E_NOTIMPL)
}

// copyMemory moves location of a block of memory.
func copyMemory(dest unsafe.Pointer, src unsafe.Pointer, length uint32) {}

// GetUserDefaultLCID retrieves current user default locale.
func GetUserDefaultLCID() uint32 {
        return uint32(0)
}

// GetMessage in message queue from runtime.
//
// This function appears to block. PeekMessage does not block.
func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (int32, error) {
        return int32(0), NewError(E_NOTIMPL)
}

// DispatchMessage to window procedure.
func DispatchMessage(msg *Msg) int32 {
        return int32(0)
}

func GetVariantDate(value uint64) (time.Time, error) {
        return time.Now(), NewError(E_NOTIMPL)
}

package ole

// Connection contains IUnknown for fluent interface interaction.
//
// Deprecated. Use oleutil package instead.
type Connection struct {
        Object *IUnknown // Access COM
}

// Initialize COM.
func (*Connection) Initialize() (err error) {
        return coInitialize()
}

// Uninitialize COM.
func (*Connection) Uninitialize() {
        CoUninitialize()
}

// Create IUnknown object based first on ProgId and then from String.
func (c *Connection) Create(progId string) (err error) {
        var clsid *GUID
        clsid, err = CLSIDFromProgID(progId)
        if err != nil {
                clsid, err = CLSIDFromString(progId)
                if err != nil {
                        return
                }
        }

        unknown, err := CreateInstance(clsid, IID_IUnknown)
        if err != nil {
                return
        }
        c.Object = unknown

        return
}

// Release IUnknown object.
func (c *Connection) Release() {
        c.Object.Release()
}

// Load COM object from list of programIDs or strings.
func (c *Connection) Load(names ...string) (errors []error) {
        var tempErrors []error = make([]error, len(names))
        var numErrors int = 0
        for _, name := range names {
                err := c.Create(name)
                if err != nil {
                        tempErrors = append(tempErrors, err)
                        numErrors += 1
                        continue
                }
                break
        }

        copy(errors, tempErrors[0:numErrors])
        return
}

// Dispatch returns Dispatch object.
func (c *Connection) Dispatch() (object *Dispatch, err error) {
        dispatch, err := c.Object.QueryInterface(IID_IDispatch)
        if err != nil {
                return
        }
        object = &Dispatch{dispatch}
        return
}

// Dispatch stores IDispatch object.
type Dispatch struct {
        Object *IDispatch // Dispatch object.
}

// Call method on IDispatch with parameters.
func (d *Dispatch) Call(method string, params ...interface{}) (result *VARIANT, err error) {
        id, err := d.GetId(method)
        if err != nil {
                return
        }

        result, err = d.Invoke(id, DISPATCH_METHOD, params)
        return
}

// MustCall method on IDispatch with parameters.
func (d *Dispatch) MustCall(method string, params ...interface{}) (result *VARIANT) {
        id, err := d.GetId(method)
        if err != nil {
                panic(err)
        }

        result, err = d.Invoke(id, DISPATCH_METHOD, params)
        if err != nil {
                panic(err)
        }

        return
}

// Get property on IDispatch with parameters.
func (d *Dispatch) Get(name string, params ...interface{}) (result *VARIANT, err error) {
        id, err := d.GetId(name)
        if err != nil {
                return
        }
        result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params)
        return
}

// MustGet property on IDispatch with parameters.
func (d *Dispatch) MustGet(name string, params ...interface{}) (result *VARIANT) {
        id, err := d.GetId(name)
        if err != nil {
                panic(err)
        }

        result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params)
        if err != nil {
                panic(err)
        }
        return
}

// Set property on IDispatch with parameters.
func (d *Dispatch) Set(name string, params ...interface{}) (result *VARIANT, err error) {
        id, err := d.GetId(name)
        if err != nil {
                return
        }
        result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params)
        return
}

// MustSet property on IDispatch with parameters.
func (d *Dispatch) MustSet(name string, params ...interface{}) (result *VARIANT) {
        id, err := d.GetId(name)
        if err != nil {
                panic(err)
        }

        result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params)
        if err != nil {
                panic(err)
        }
        return
}

// GetId retrieves ID of name on IDispatch.
func (d *Dispatch) GetId(name string) (id int32, err error) {
        var dispid []int32
        dispid, err = d.Object.GetIDsOfName([]string{name})
        if err != nil {
                return
        }
        id = dispid[0]
        return
}

// GetIds retrieves all IDs of names on IDispatch.
func (d *Dispatch) GetIds(names ...string) (dispid []int32, err error) {
        dispid, err = d.Object.GetIDsOfName(names)
        return
}

// Invoke IDispatch on DisplayID of dispatch type with parameters.
//
// There have been problems where if send cascading params..., it would error
// out because the parameters would be empty.
func (d *Dispatch) Invoke(id int32, dispatch int16, params []interface{}) (result *VARIANT, err error) {
        if len(params) < 1 {
                result, err = d.Object.Invoke(id, dispatch)
        } else {
                result, err = d.Object.Invoke(id, dispatch, params...)
        }
        return
}

// Release IDispatch object.
func (d *Dispatch) Release() {
        d.Object.Release()
}

// Connect initializes COM and attempts to load IUnknown based on given names.
func Connect(names ...string) (connection *Connection) {
        connection.Initialize()
        connection.Load(names...)
        return
}

package ole

// OleError stores COM errors.
type OleError struct {
        hr          uintptr
        description string
        subError    error
}

// NewError creates new error with HResult.
func NewError(hr uintptr) *OleError {
        return &OleError{hr: hr}
}

// NewErrorWithDescription creates new COM error with HResult and description.
func NewErrorWithDescription(hr uintptr, description string) *OleError {
        return &OleError{hr: hr, description: description}
}

// NewErrorWithSubError creates new COM error with parent error.
func NewErrorWithSubError(hr uintptr, description string, err error) *OleError {
        return &OleError{hr: hr, description: description, subError: err}
}

// Code is the HResult.
func (v *OleError) Code() uintptr {
        return uintptr(v.hr)
}

// String description, either manually set or format message with error code.
func (v *OleError) String() string {
        if v.description != "" {
                return errstr(int(v.hr)) + " (" + v.description + ")"
        }
        return errstr(int(v.hr))
}

// Error implements error interface.
func (v *OleError) Error() string {
        return v.String()
}

// Description retrieves error summary, if there is one.
func (v *OleError) Description() string {
        return v.description
}

// SubError returns parent error, if there is one.
func (v *OleError) SubError() error {
        return v.subError
}

// Unwrap returns parent error, if there is one.
func (v *OleError) Unwrap() error {
        return v.subError
}

// +build !windows

package ole

// errstr converts error code to string.
func errstr(errno int) string {
        return ""
}

package ole

var (
        // IID_NULL is null Interface ID, used when no other Interface ID is known.
        IID_NULL = NewGUID("{00000000-0000-0000-0000-000000000000}")

        // IID_IUnknown is for IUnknown interfaces.
        IID_IUnknown = NewGUID("{00000000-0000-0000-C000-000000000046}")

        // IID_IDispatch is for IDispatch interfaces.
        IID_IDispatch = NewGUID("{00020400-0000-0000-C000-000000000046}")

        // IID_IEnumVariant is for IEnumVariant interfaces
        IID_IEnumVariant = NewGUID("{00020404-0000-0000-C000-000000000046}")

        // IID_IConnectionPointContainer is for IConnectionPointContainer interfaces.
        IID_IConnectionPointContainer = NewGUID("{B196B284-BAB4-101A-B69C-00AA00341D07}")

        // IID_IConnectionPoint is for IConnectionPoint interfaces.
        IID_IConnectionPoint = NewGUID("{B196B286-BAB4-101A-B69C-00AA00341D07}")

        // IID_IInspectable is for IInspectable interfaces.
        IID_IInspectable = NewGUID("{AF86E2E0-B12D-4C6A-9C5A-D7AA65101E90}")

        // IID_IProvideClassInfo is for IProvideClassInfo interfaces.
        IID_IProvideClassInfo = NewGUID("{B196B283-BAB4-101A-B69C-00AA00341D07}")
)

// These are for testing and not part of any library.
var (
        // IID_ICOMTestString is for ICOMTestString interfaces.
        //
        // {E0133EB4-C36F-469A-9D3D-C66B84BE19ED}
        IID_ICOMTestString = NewGUID("{E0133EB4-C36F-469A-9D3D-C66B84BE19ED}")

        // IID_ICOMTestInt8 is for ICOMTestInt8 interfaces.
        //
        // {BEB06610-EB84-4155-AF58-E2BFF53680B4}
        IID_ICOMTestInt8 = NewGUID("{BEB06610-EB84-4155-AF58-E2BFF53680B4}")

        // IID_ICOMTestInt16 is for ICOMTestInt16 interfaces.
        //
        // {DAA3F9FA-761E-4976-A860-8364CE55F6FC}
        IID_ICOMTestInt16 = NewGUID("{DAA3F9FA-761E-4976-A860-8364CE55F6FC}")

        // IID_ICOMTestInt32 is for ICOMTestInt32 interfaces.
        //
        // {E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0}
        IID_ICOMTestInt32 = NewGUID("{E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0}")

        // IID_ICOMTestInt64 is for ICOMTestInt64 interfaces.
        //
        // {8D437CBC-B3ED-485C-BC32-C336432A1623}
        IID_ICOMTestInt64 = NewGUID("{8D437CBC-B3ED-485C-BC32-C336432A1623}")

        // IID_ICOMTestFloat is for ICOMTestFloat interfaces.
        //
        // {BF1ED004-EA02-456A-AA55-2AC8AC6B054C}
        IID_ICOMTestFloat = NewGUID("{BF1ED004-EA02-456A-AA55-2AC8AC6B054C}")

        // IID_ICOMTestDouble is for ICOMTestDouble interfaces.
        //
        // {BF908A81-8687-4E93-999F-D86FAB284BA0}
        IID_ICOMTestDouble = NewGUID("{BF908A81-8687-4E93-999F-D86FAB284BA0}")

        // IID_ICOMTestBoolean is for ICOMTestBoolean interfaces.
        //
        // {D530E7A6-4EE8-40D1-8931-3D63B8605010}
        IID_ICOMTestBoolean = NewGUID("{D530E7A6-4EE8-40D1-8931-3D63B8605010}")

        // IID_ICOMEchoTestObject is for ICOMEchoTestObject interfaces.
        //
        // {6485B1EF-D780-4834-A4FE-1EBB51746CA3}
        IID_ICOMEchoTestObject = NewGUID("{6485B1EF-D780-4834-A4FE-1EBB51746CA3}")

        // IID_ICOMTestTypes is for ICOMTestTypes interfaces.
        //
        // {CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0}
        IID_ICOMTestTypes = NewGUID("{CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0}")

        // CLSID_COMEchoTestObject is for COMEchoTestObject class.
        //
        // {3C24506A-AE9E-4D50-9157-EF317281F1B0}
        CLSID_COMEchoTestObject = NewGUID("{3C24506A-AE9E-4D50-9157-EF317281F1B0}")

        // CLSID_COMTestScalarClass is for COMTestScalarClass class.
        //
        // {865B85C5-0334-4AC6-9EF6-AACEC8FC5E86}
        CLSID_COMTestScalarClass = NewGUID("{865B85C5-0334-4AC6-9EF6-AACEC8FC5E86}")
)

const hextable = "0123456789ABCDEF"
const emptyGUID = "{00000000-0000-0000-0000-000000000000}"

// GUID is Windows API specific GUID type.
//
// This exists to match Windows GUID type for direct passing for COM.
// Format is in xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxxx.
type GUID struct {
        Data1 uint32
        Data2 uint16
        Data3 uint16
        Data4 [8]byte
}

// NewGUID converts the given string into a globally unique identifier that is
// compliant with the Windows API.
//
// The supplied string may be in any of these formats:
//
//  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//  XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
//  {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
//
// The conversion of the supplied string is not case-sensitive.
func NewGUID(guid string) *GUID {
        d := []byte(guid)
        var d1, d2, d3, d4a, d4b []byte

        switch len(d) {
        case 38:
                if d[0] != '{' || d[37] != '}' {
                        return nil
                }
                d = d[1:37]
                fallthrough
        case 36:
                if d[8] != '-' || d[13] != '-' || d[18] != '-' || d[23] != '-' {
                        return nil
                }
                d1 = d[0:8]
                d2 = d[9:13]
                d3 = d[14:18]
                d4a = d[19:23]
                d4b = d[24:36]
        case 32:
                d1 = d[0:8]
                d2 = d[8:12]
                d3 = d[12:16]
                d4a = d[16:20]
                d4b = d[20:32]
        default:
                return nil
        }

        var g GUID
        var ok1, ok2, ok3, ok4 bool
        g.Data1, ok1 = decodeHexUint32(d1)
        g.Data2, ok2 = decodeHexUint16(d2)
        g.Data3, ok3 = decodeHexUint16(d3)
        g.Data4, ok4 = decodeHexByte64(d4a, d4b)
        if ok1 && ok2 && ok3 && ok4 {
                return &g
        }
        return nil
}

func decodeHexUint32(src []byte) (value uint32, ok bool) {
        var b1, b2, b3, b4 byte
        var ok1, ok2, ok3, ok4 bool
        b1, ok1 = decodeHexByte(src[0], src[1])
        b2, ok2 = decodeHexByte(src[2], src[3])
        b3, ok3 = decodeHexByte(src[4], src[5])
        b4, ok4 = decodeHexByte(src[6], src[7])
        value = (uint32(b1) << 24) | (uint32(b2) << 16) | (uint32(b3) << 8) | uint32(b4)
        ok = ok1 && ok2 && ok3 && ok4
        return
}

func decodeHexUint16(src []byte) (value uint16, ok bool) {
        var b1, b2 byte
        var ok1, ok2 bool
        b1, ok1 = decodeHexByte(src[0], src[1])
        b2, ok2 = decodeHexByte(src[2], src[3])
        value = (uint16(b1) << 8) | uint16(b2)
        ok = ok1 && ok2
        return
}

func decodeHexByte64(s1 []byte, s2 []byte) (value [8]byte, ok bool) {
        var ok1, ok2, ok3, ok4, ok5, ok6, ok7, ok8 bool
        value[0], ok1 = decodeHexByte(s1[0], s1[1])
        value[1], ok2 = decodeHexByte(s1[2], s1[3])
        value[2], ok3 = decodeHexByte(s2[0], s2[1])
        value[3], ok4 = decodeHexByte(s2[2], s2[3])
        value[4], ok5 = decodeHexByte(s2[4], s2[5])
        value[5], ok6 = decodeHexByte(s2[6], s2[7])
        value[6], ok7 = decodeHexByte(s2[8], s2[9])
        value[7], ok8 = decodeHexByte(s2[10], s2[11])
        ok = ok1 && ok2 && ok3 && ok4 && ok5 && ok6 && ok7 && ok8
        return
}

func decodeHexByte(c1, c2 byte) (value byte, ok bool) {
        var n1, n2 byte
        var ok1, ok2 bool
        n1, ok1 = decodeHexChar(c1)
        n2, ok2 = decodeHexChar(c2)
        value = (n1 << 4) | n2
        ok = ok1 && ok2
        return
}

func decodeHexChar(c byte) (byte, bool) {
        switch {
        case '0' <= c && c <= '9':
                return c - '0', true
        case 'a' <= c && c <= 'f':
                return c - 'a' + 10, true
        case 'A' <= c && c <= 'F':
                return c - 'A' + 10, true
        }

        return 0, false
}

// String converts the GUID to string form. It will adhere to this pattern:
//
//  {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
//
// If the GUID is nil, the string representation of an empty GUID is returned:
//
//  {00000000-0000-0000-0000-000000000000}
func (guid *GUID) String() string {
        if guid == nil {
                return emptyGUID
        }

        var c [38]byte
        c[0] = '{'
        putUint32Hex(c[1:9], guid.Data1)
        c[9] = '-'
        putUint16Hex(c[10:14], guid.Data2)
        c[14] = '-'
        putUint16Hex(c[15:19], guid.Data3)
        c[19] = '-'
        putByteHex(c[20:24], guid.Data4[0:2])
        c[24] = '-'
        putByteHex(c[25:37], guid.Data4[2:8])
        c[37] = '}'
        return string(c[:])
}

func putUint32Hex(b []byte, v uint32) {
        b[0] = hextable[byte(v>>24)>>4]
        b[1] = hextable[byte(v>>24)&0x0f]
        b[2] = hextable[byte(v>>16)>>4]
        b[3] = hextable[byte(v>>16)&0x0f]
        b[4] = hextable[byte(v>>8)>>4]
        b[5] = hextable[byte(v>>8)&0x0f]
        b[6] = hextable[byte(v)>>4]
        b[7] = hextable[byte(v)&0x0f]
}

func putUint16Hex(b []byte, v uint16) {
        b[0] = hextable[byte(v>>8)>>4]
        b[1] = hextable[byte(v>>8)&0x0f]
        b[2] = hextable[byte(v)>>4]
        b[3] = hextable[byte(v)&0x0f]
}

func putByteHex(dst, src []byte) {
        for i := 0; i < len(src); i++ {
                dst[i*2] = hextable[src[i]>>4]
                dst[i*2+1] = hextable[src[i]&0x0f]
        }
}

// IsEqualGUID compares two GUID.
//
// Not constant time comparison.
func IsEqualGUID(guid1 *GUID, guid2 *GUID) bool {
        return guid1.Data1 == guid2.Data1 &&
                guid1.Data2 == guid2.Data2 &&
                guid1.Data3 == guid2.Data3 &&
                guid1.Data4[0] == guid2.Data4[0] &&
                guid1.Data4[1] == guid2.Data4[1] &&
                guid1.Data4[2] == guid2.Data4[2] &&
                guid1.Data4[3] == guid2.Data4[3] &&
                guid1.Data4[4] == guid2.Data4[4] &&
                guid1.Data4[5] == guid2.Data4[5] &&
                guid1.Data4[6] == guid2.Data4[6] &&
                guid1.Data4[7] == guid2.Data4[7]
}

package ole

import "unsafe"

type IConnectionPoint struct {
        IUnknown
}

type IConnectionPointVtbl struct {
        IUnknownVtbl
        GetConnectionInterface      uintptr
        GetConnectionPointContainer uintptr
        Advise                      uintptr
        Unadvise                    uintptr
        EnumConnections             uintptr
}

func (v *IConnectionPoint) VTable() *IConnectionPointVtbl {
        return (*IConnectionPointVtbl)(unsafe.Pointer(v.RawVTable))
}

// +build !windows

package ole

import "unsafe"

func (v *IConnectionPoint) GetConnectionInterface(piid **GUID) int32 {
        return int32(0)
}

func (v *IConnectionPoint) Advise(unknown *IUnknown) (uint32, error) {
        return uint32(0), NewError(E_NOTIMPL)
}

func (v *IConnectionPoint) Unadvise(cookie uint32) error {
        return NewError(E_NOTIMPL)
}

func (v *IConnectionPoint) EnumConnections(p *unsafe.Pointer) (err error) {
        return NewError(E_NOTIMPL)
}

package ole

import "unsafe"

type IConnectionPointContainer struct {
        IUnknown
}

type IConnectionPointContainerVtbl struct {
        IUnknownVtbl
        EnumConnectionPoints uintptr
        FindConnectionPoint  uintptr
}

func (v *IConnectionPointContainer) VTable() *IConnectionPointContainerVtbl {
        return (*IConnectionPointContainerVtbl)(unsafe.Pointer(v.RawVTable))
}

// +build !windows

package ole

func (v *IConnectionPointContainer) EnumConnectionPoints(points interface{}) error {
        return NewError(E_NOTIMPL)
}

func (v *IConnectionPointContainer) FindConnectionPoint(iid *GUID, point **IConnectionPoint) error {
        return NewError(E_NOTIMPL)
}

package ole

import "unsafe"

type IDispatch struct {
        IUnknown
}

type IDispatchVtbl struct {
        IUnknownVtbl
        GetTypeInfoCount uintptr
        GetTypeInfo      uintptr
        GetIDsOfNames    uintptr
        Invoke           uintptr
}

func (v *IDispatch) VTable() *IDispatchVtbl {
        return (*IDispatchVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *IDispatch) GetIDsOfName(names []string) (dispid []int32, err error) {
        dispid, err = getIDsOfName(v, names)
        return
}

func (v *IDispatch) Invoke(dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) {
        result, err = invoke(v, dispid, dispatch, params...)
        return
}

func (v *IDispatch) GetTypeInfoCount() (c uint32, err error) {
        c, err = getTypeInfoCount(v)
        return
}

func (v *IDispatch) GetTypeInfo() (tinfo *ITypeInfo, err error) {
        tinfo, err = getTypeInfo(v)
        return
}

// GetSingleIDOfName is a helper that returns single display ID for IDispatch name.
//
// This replaces the common pattern of attempting to get a single name from the list of available
// IDs. It gives the first ID, if it is available.
func (v *IDispatch) GetSingleIDOfName(name string) (displayID int32, err error) {
        var displayIDs []int32
        displayIDs, err = v.GetIDsOfName([]string{name})
        if err != nil {
                return
        }
        displayID = displayIDs[0]
        return
}

// InvokeWithOptionalArgs accepts arguments as an array, works like Invoke.
//
// Accepts name and will attempt to retrieve Display ID to pass to Invoke.
//
// Passing params as an array is a workaround that could be fixed in later versions of Go that
// prevent passing empty params. During testing it was discovered that this is an acceptable way of
// getting around not being able to pass params normally.
func (v *IDispatch) InvokeWithOptionalArgs(name string, dispatch int16, params []interface{}) (result *VARIANT, err error) {
        displayID, err := v.GetSingleIDOfName(name)
        if err != nil {
                return
        }

        if len(params) < 1 {
                result, err = v.Invoke(displayID, dispatch)
        } else {
                result, err = v.Invoke(displayID, dispatch, params...)
        }

        return
}

// CallMethod invokes named function with arguments on object.
func (v *IDispatch) CallMethod(name string, params ...interface{}) (*VARIANT, error) {
        return v.InvokeWithOptionalArgs(name, DISPATCH_METHOD, params)
}

// GetProperty retrieves the property with the name with the ability to pass arguments.
//
// Most of the time you will not need to pass arguments as most objects do not allow for this
// feature. Or at least, should not allow for this feature. Some servers don't follow best practices
// and this is provided for those edge cases.
func (v *IDispatch) GetProperty(name string, params ...interface{}) (*VARIANT, error) {
        return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYGET, params)
}

// PutProperty attempts to mutate a property in the object.
func (v *IDispatch) PutProperty(name string, params ...interface{}) (*VARIANT, error) {
        return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYPUT, params)
}

// +build !windows

package ole

func getIDsOfName(disp *IDispatch, names []string) ([]int32, error) {
        return []int32{}, NewError(E_NOTIMPL)
}

func getTypeInfoCount(disp *IDispatch) (uint32, error) {
        return uint32(0), NewError(E_NOTIMPL)
}

func getTypeInfo(disp *IDispatch) (*ITypeInfo, error) {
        return nil, NewError(E_NOTIMPL)
}

func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (*VARIANT, error) {
        return nil, NewError(E_NOTIMPL)
}

package ole

import "unsafe"

type IEnumVARIANT struct {
        IUnknown
}

type IEnumVARIANTVtbl struct {
        IUnknownVtbl
        Next  uintptr
        Skip  uintptr
        Reset uintptr
        Clone uintptr
}

func (v *IEnumVARIANT) VTable() *IEnumVARIANTVtbl {
        return (*IEnumVARIANTVtbl)(unsafe.Pointer(v.RawVTable))
}

// +build !windows

package ole

func (enum *IEnumVARIANT) Clone() (*IEnumVARIANT, error) {
        return nil, NewError(E_NOTIMPL)
}

func (enum *IEnumVARIANT) Reset() error {
        return NewError(E_NOTIMPL)
}

func (enum *IEnumVARIANT) Skip(celt uint) error {
        return NewError(E_NOTIMPL)
}

func (enum *IEnumVARIANT) Next(celt uint) (VARIANT, uint, error) {
        return NewVariant(VT_NULL, int64(0)), 0, NewError(E_NOTIMPL)
}

package ole

import "unsafe"

type IInspectable struct {
        IUnknown
}

type IInspectableVtbl struct {
        IUnknownVtbl
        GetIIds             uintptr
        GetRuntimeClassName uintptr
        GetTrustLevel       uintptr
}

func (v *IInspectable) VTable() *IInspectableVtbl {
        return (*IInspectableVtbl)(unsafe.Pointer(v.RawVTable))
}

// +build !windows

package ole

func (v *IInspectable) GetIids() ([]*GUID, error) {
        return []*GUID{}, NewError(E_NOTIMPL)
}

func (v *IInspectable) GetRuntimeClassName() (string, error) {
        return "", NewError(E_NOTIMPL)
}

func (v *IInspectable) GetTrustLevel() (uint32, error) {
        return uint32(0), NewError(E_NOTIMPL)
}

package ole

import "unsafe"

type IProvideClassInfo struct {
        IUnknown
}

type IProvideClassInfoVtbl struct {
        IUnknownVtbl
        GetClassInfo uintptr
}

func (v *IProvideClassInfo) VTable() *IProvideClassInfoVtbl {
        return (*IProvideClassInfoVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *IProvideClassInfo) GetClassInfo() (cinfo *ITypeInfo, err error) {
        cinfo, err = getClassInfo(v)
        return
}

// +build !windows

package ole

func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) {
        return nil, NewError(E_NOTIMPL)
}

package ole

import "unsafe"

type ITypeInfo struct {
        IUnknown
}

type ITypeInfoVtbl struct {
        IUnknownVtbl
        GetTypeAttr          uintptr
        GetTypeComp          uintptr
        GetFuncDesc          uintptr
        GetVarDesc           uintptr
        GetNames             uintptr
        GetRefTypeOfImplType uintptr
        GetImplTypeFlags     uintptr
        GetIDsOfNames        uintptr
        Invoke               uintptr
        GetDocumentation     uintptr
        GetDllEntry          uintptr
        GetRefTypeInfo       uintptr
        AddressOfMember      uintptr
        CreateInstance       uintptr
        GetMops              uintptr
        GetContainingTypeLib uintptr
        ReleaseTypeAttr      uintptr
        ReleaseFuncDesc      uintptr
        ReleaseVarDesc       uintptr
}

func (v *ITypeInfo) VTable() *ITypeInfoVtbl {
        return (*ITypeInfoVtbl)(unsafe.Pointer(v.RawVTable))
}

// +build !windows

package ole

func (v *ITypeInfo) GetTypeAttr() (*TYPEATTR, error) {
        return nil, NewError(E_NOTIMPL)
}

package ole

import "unsafe"

type IUnknown struct {
        RawVTable *interface{}
}

type IUnknownVtbl struct {
        QueryInterface uintptr
        AddRef         uintptr
        Release        uintptr
}

type UnknownLike interface {
        QueryInterface(iid *GUID) (disp *IDispatch, err error)
        AddRef() int32
        Release() int32
}

func (v *IUnknown) VTable() *IUnknownVtbl {
        return (*IUnknownVtbl)(unsafe.Pointer(v.RawVTable))
}

func (v *IUnknown) PutQueryInterface(interfaceID *GUID, obj interface{}) error {
        return reflectQueryInterface(v, v.VTable().QueryInterface, interfaceID, obj)
}

func (v *IUnknown) IDispatch(interfaceID *GUID) (dispatch *IDispatch, err error) {
        err = v.PutQueryInterface(interfaceID, &dispatch)
        return
}

func (v *IUnknown) IEnumVARIANT(interfaceID *GUID) (enum *IEnumVARIANT, err error) {
        err = v.PutQueryInterface(interfaceID, &enum)
        return
}

func (v *IUnknown) QueryInterface(iid *GUID) (*IDispatch, error) {
        return queryInterface(v, iid)
}

func (v *IUnknown) MustQueryInterface(iid *GUID) (disp *IDispatch) {
        unk, err := queryInterface(v, iid)
        if err != nil {
                panic(err)
        }
        return unk
}

func (v *IUnknown) AddRef() int32 {
        return addRef(v)
}

func (v *IUnknown) Release() int32 {
        return release(v)
}

// +build !windows

package ole

func reflectQueryInterface(self interface{}, method uintptr, interfaceID *GUID, obj interface{}) (err error) {
        return NewError(E_NOTIMPL)
}

func queryInterface(unk *IUnknown, iid *GUID) (disp *IDispatch, err error) {
        return nil, NewError(E_NOTIMPL)
}

func addRef(unk *IUnknown) int32 {
        return 0
}

func release(unk *IUnknown) int32 {
        return 0
}

package ole

import (
        "fmt"
        "strings"
        "unsafe"
)

// DISPPARAMS are the arguments that passed to methods or property.
type DISPPARAMS struct {
        rgvarg            uintptr
        rgdispidNamedArgs uintptr
        cArgs             uint32
        cNamedArgs        uint32
}

// EXCEPINFO defines exception info.
type EXCEPINFO struct {
        wCode             uint16
        wReserved         uint16
        bstrSource        *uint16
        bstrDescription   *uint16
        bstrHelpFile      *uint16
        dwHelpContext     uint32
        pvReserved        uintptr
        pfnDeferredFillIn uintptr
        scode             uint32

        // Go-specific part. Don't move upper cos it'll break structure layout for native code.
        rendered    bool
        source      string
        description string
        helpFile    string
}

// renderStrings translates BSTR strings to Go ones so `.Error` and `.String`
// could be safely called after `.Clear`. We need this when we can't rely on
// a caller to call `.Clear`.
func (e *EXCEPINFO) renderStrings() {
        e.rendered = true
        if e.bstrSource == nil {
                e.source = "<nil>"
        } else {
                e.source = BstrToString(e.bstrSource)
        }
        if e.bstrDescription == nil {
                e.description = "<nil>"
        } else {
                e.description = BstrToString(e.bstrDescription)
        }
        if e.bstrHelpFile == nil {
                e.helpFile = "<nil>"
        } else {
                e.helpFile = BstrToString(e.bstrHelpFile)
        }
}

// Clear frees BSTR strings inside an EXCEPINFO and set it to NULL.
func (e *EXCEPINFO) Clear() {
        freeBSTR := func(s *uint16) {
                // SysFreeString don't return errors and is safe for call's on NULL.
                // https://docs.microsoft.com/en-us/windows/win32/api/oleauto/nf-oleauto-sysfreestring
                _ = SysFreeString((*int16)(unsafe.Pointer(s)))
        }

        if e.bstrSource != nil {
                freeBSTR(e.bstrSource)
                e.bstrSource = nil
        }
        if e.bstrDescription != nil {
                freeBSTR(e.bstrDescription)
                e.bstrDescription = nil
        }
        if e.bstrHelpFile != nil {
                freeBSTR(e.bstrHelpFile)
                e.bstrHelpFile = nil
        }
}

// WCode return wCode in EXCEPINFO.
func (e EXCEPINFO) WCode() uint16 {
        return e.wCode
}

// SCODE return scode in EXCEPINFO.
func (e EXCEPINFO) SCODE() uint32 {
        return e.scode
}

// String convert EXCEPINFO to string.
func (e EXCEPINFO) String() string {
        if !e.rendered {
                e.renderStrings()
        }
        return fmt.Sprintf(
                "wCode: %#x, bstrSource: %v, bstrDescription: %v, bstrHelpFile: %v, dwHelpContext: %#x, scode: %#x",
                e.wCode, e.source, e.description, e.helpFile, e.dwHelpContext, e.scode,
        )
}

// Error implements error interface and returns error string.
func (e EXCEPINFO) Error() string {
        if !e.rendered {
                e.renderStrings()
        }

        if e.description != "<nil>" {
                return strings.TrimSpace(e.description)
        }

        code := e.scode
        if e.wCode != 0 {
                code = uint32(e.wCode)
        }
        return fmt.Sprintf("%v: %#x", e.source, code)
}

// PARAMDATA defines parameter data type.
type PARAMDATA struct {
        Name *int16
        Vt   uint16
}

// METHODDATA defines method info.
type METHODDATA struct {
        Name     *uint16
        Data     *PARAMDATA
        Dispid   int32
        Meth     uint32
        CC       int32
        CArgs    uint32
        Flags    uint16
        VtReturn uint32
}

// INTERFACEDATA defines interface info.
type INTERFACEDATA struct {
        MethodData *METHODDATA
        CMembers   uint32
}

// Point is 2D vector type.
type Point struct {
        X int32
        Y int32
}

// Msg is message between processes.
type Msg struct {
        Hwnd    uint32
        Message uint32
        Wparam  int32
        Lparam  int32
        Time    uint32
        Pt      Point
}

// TYPEDESC defines data type.
type TYPEDESC struct {
        Hreftype uint32
        VT       uint16
}

// IDLDESC defines IDL info.
type IDLDESC struct {
        DwReserved uint32
        WIDLFlags  uint16
}

// TYPEATTR defines type info.
type TYPEATTR struct {
        Guid             GUID
        Lcid             uint32
        dwReserved       uint32
        MemidConstructor int32
        MemidDestructor  int32
        LpstrSchema      *uint16
        CbSizeInstance   uint32
        Typekind         int32
        CFuncs           uint16
        CVars            uint16
        CImplTypes       uint16
        CbSizeVft        uint16
        CbAlignment      uint16
        WTypeFlags       uint16
        WMajorVerNum     uint16
        WMinorVerNum     uint16
        TdescAlias       TYPEDESC
        IdldescType      IDLDESC
}

// +build !windows

package ole

import (
        "unsafe"
)

// safeArrayAccessData returns raw array pointer.
//
// AKA: SafeArrayAccessData in Windows API.
func safeArrayAccessData(safearray *SafeArray) (uintptr, error) {
        return uintptr(0), NewError(E_NOTIMPL)
}

// safeArrayUnaccessData releases raw array.
//
// AKA: SafeArrayUnaccessData in Windows API.
func safeArrayUnaccessData(safearray *SafeArray) error {
        return NewError(E_NOTIMPL)
}

// safeArrayAllocData allocates SafeArray.
//
// AKA: SafeArrayAllocData in Windows API.
func safeArrayAllocData(safearray *SafeArray) error {
        return NewError(E_NOTIMPL)
}

// safeArrayAllocDescriptor allocates SafeArray.
//
// AKA: SafeArrayAllocDescriptor in Windows API.
func safeArrayAllocDescriptor(dimensions uint32) (*SafeArray, error) {
        return nil, NewError(E_NOTIMPL)
}

// safeArrayAllocDescriptorEx allocates SafeArray.
//
// AKA: SafeArrayAllocDescriptorEx in Windows API.
func safeArrayAllocDescriptorEx(variantType VT, dimensions uint32) (*SafeArray, error) {
        return nil, NewError(E_NOTIMPL)
}

// safeArrayCopy returns copy of SafeArray.
//
// AKA: SafeArrayCopy in Windows API.
func safeArrayCopy(original *SafeArray) (*SafeArray, error) {
        return nil, NewError(E_NOTIMPL)
}

// safeArrayCopyData duplicates SafeArray into another SafeArray object.
//
// AKA: SafeArrayCopyData in Windows API.
func safeArrayCopyData(original *SafeArray, duplicate *SafeArray) error {
        return NewError(E_NOTIMPL)
}

// safeArrayCreate creates SafeArray.
//
// AKA: SafeArrayCreate in Windows API.
func safeArrayCreate(variantType VT, dimensions uint32, bounds *SafeArrayBound) (*SafeArray, error) {
        return nil, NewError(E_NOTIMPL)
}

// safeArrayCreateEx creates SafeArray.
//
// AKA: SafeArrayCreateEx in Windows API.
func safeArrayCreateEx(variantType VT, dimensions uint32, bounds *SafeArrayBound, extra uintptr) (*SafeArray, error) {
        return nil, NewError(E_NOTIMPL)
}

// safeArrayCreateVector creates SafeArray.
//
// AKA: SafeArrayCreateVector in Windows API.
func safeArrayCreateVector(variantType VT, lowerBound int32, length uint32) (*SafeArray, error) {
        return nil, NewError(E_NOTIMPL)
}

// safeArrayCreateVectorEx creates SafeArray.
//
// AKA: SafeArrayCreateVectorEx in Windows API.
func safeArrayCreateVectorEx(variantType VT, lowerBound int32, length uint32, extra uintptr) (*SafeArray, error) {
        return nil, NewError(E_NOTIMPL)
}

// safeArrayDestroy destroys SafeArray object.
//
// AKA: SafeArrayDestroy in Windows API.
func safeArrayDestroy(safearray *SafeArray) error {
        return NewError(E_NOTIMPL)
}

// safeArrayDestroyData destroys SafeArray object.
//
// AKA: SafeArrayDestroyData in Windows API.
func safeArrayDestroyData(safearray *SafeArray) error {
        return NewError(E_NOTIMPL)
}

// safeArrayDestroyDescriptor destroys SafeArray object.
//
// AKA: SafeArrayDestroyDescriptor in Windows API.
func safeArrayDestroyDescriptor(safearray *SafeArray) error {
        return NewError(E_NOTIMPL)
}

// safeArrayGetDim is the amount of dimensions in the SafeArray.
//
// SafeArrays may have multiple dimensions. Meaning, it could be
// multidimensional array.
//
// AKA: SafeArrayGetDim in Windows API.
func safeArrayGetDim(safearray *SafeArray) (*uint32, error) {
        u := uint32(0)
        return &u, NewError(E_NOTIMPL)
}

// safeArrayGetElementSize is the element size in bytes.
//
// AKA: SafeArrayGetElemsize in Windows API.
func safeArrayGetElementSize(safearray *SafeArray) (*uint32, error) {
        u := uint32(0)
        return &u, NewError(E_NOTIMPL)
}

// safeArrayGetElement retrieves element at given index.
func safeArrayGetElement(safearray *SafeArray, index int32, pv unsafe.Pointer) error {
        return NewError(E_NOTIMPL)
}

// safeArrayGetElement retrieves element at given index and converts to string.
func safeArrayGetElementString(safearray *SafeArray, index int32) (string, error) {
        return "", NewError(E_NOTIMPL)
}

// safeArrayGetIID is the InterfaceID of the elements in the SafeArray.
//
// AKA: SafeArrayGetIID in Windows API.
func safeArrayGetIID(safearray *SafeArray) (*GUID, error) {
        return nil, NewError(E_NOTIMPL)
}

// safeArrayGetLBound returns lower bounds of SafeArray.
//
// SafeArrays may have multiple dimensions. Meaning, it could be
// multidimensional array.
//
// AKA: SafeArrayGetLBound in Windows API.
func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (int32, error) {
        return int32(0), NewError(E_NOTIMPL)
}

// safeArrayGetUBound returns upper bounds of SafeArray.
//
// SafeArrays may have multiple dimensions. Meaning, it could be
// multidimensional array.
//
// AKA: SafeArrayGetUBound in Windows API.
func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (int32, error) {
        return int32(0), NewError(E_NOTIMPL)
}

// safeArrayGetVartype returns data type of SafeArray.
//
// AKA: SafeArrayGetVartype in Windows API.
func safeArrayGetVartype(safearray *SafeArray) (uint16, error) {
        return uint16(0), NewError(E_NOTIMPL)
}

// safeArrayLock locks SafeArray for reading to modify SafeArray.
//
// This must be called during some calls to ensure that another process does not
// read or write to the SafeArray during editing.
//
// AKA: SafeArrayLock in Windows API.
func safeArrayLock(safearray *SafeArray) error {
        return NewError(E_NOTIMPL)
}

// safeArrayUnlock unlocks SafeArray for reading.
//
// AKA: SafeArrayUnlock in Windows API.
func safeArrayUnlock(safearray *SafeArray) error {
        return NewError(E_NOTIMPL)
}

// safeArrayPutElement stores the data element at the specified location in the
// array.
//
// AKA: SafeArrayPutElement in Windows API.
func safeArrayPutElement(safearray *SafeArray, index int64, element uintptr) error {
        return NewError(E_NOTIMPL)
}

// safeArrayGetRecordInfo accesses IRecordInfo info for custom types.
//
// AKA: SafeArrayGetRecordInfo in Windows API.
//
// XXX: Must implement IRecordInfo interface for this to return.
func safeArrayGetRecordInfo(safearray *SafeArray) (interface{}, error) {
        return nil, NewError(E_NOTIMPL)
}

// safeArraySetRecordInfo mutates IRecordInfo info for custom types.
//
// AKA: SafeArraySetRecordInfo in Windows API.
//
// XXX: Must implement IRecordInfo interface for this to return.
func safeArraySetRecordInfo(safearray *SafeArray, recordInfo interface{}) error {
        return NewError(E_NOTIMPL)
}

// Helper for converting SafeArray to array of objects.

package ole

import (
        "unsafe"
)

type SafeArrayConversion struct {
        Array *SafeArray
}

func (sac *SafeArrayConversion) ToStringArray() (strings []string) {
        totalElements, _ := sac.TotalElements(0)
        strings = make([]string, totalElements)

        for i := int32(0); i < totalElements; i++ {
                strings[int32(i)], _ = safeArrayGetElementString(sac.Array, i)
        }

        return
}

func (sac *SafeArrayConversion) ToByteArray() (bytes []byte) {
        totalElements, _ := sac.TotalElements(0)
        bytes = make([]byte, totalElements)

        for i := int32(0); i < totalElements; i++ {
                safeArrayGetElement(sac.Array, i, unsafe.Pointer(&bytes[int32(i)]))
        }

        return
}

func (sac *SafeArrayConversion) ToValueArray() (values []interface{}) {
        totalElements, _ := sac.TotalElements(0)
        values = make([]interface{}, totalElements)
        vt, _ := safeArrayGetVartype(sac.Array)

        for i := int32(0); i < totalElements; i++ {
                switch VT(vt) {
                case VT_BOOL:
                        var v bool
                        safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
                        values[i] = v
                case VT_I1:
                        var v int8
                        safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
                        values[i] = v
                case VT_I2:
                        var v int16
                        safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
                        values[i] = v
                case VT_I4:
                        var v int32
                        safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
                        values[i] = v
                case VT_I8:
                        var v int64
                        safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
                        values[i] = v
                case VT_UI1:
                        var v uint8
                        safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
                        values[i] = v
                case VT_UI2:
                        var v uint16
                        safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
                        values[i] = v
                case VT_UI4:
                        var v uint32
                        safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
                        values[i] = v
                case VT_UI8:
                        var v uint64
                        safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
                        values[i] = v
                case VT_R4:
                        var v float32
                        safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
                        values[i] = v
                case VT_R8:
                        var v float64
                        safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
                        values[i] = v
                case VT_BSTR:
                        v , _ := safeArrayGetElementString(sac.Array, i)
                        values[i] = v
                case VT_VARIANT:
                        var v VARIANT
                        safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
                        values[i] = v.Value()
                        v.Clear()
                default:
                        // TODO
                }
        }

        return
}

func (sac *SafeArrayConversion) GetType() (varType uint16, err error) {
        return safeArrayGetVartype(sac.Array)
}

func (sac *SafeArrayConversion) GetDimensions() (dimensions *uint32, err error) {
        return safeArrayGetDim(sac.Array)
}

func (sac *SafeArrayConversion) GetSize() (length *uint32, err error) {
        return safeArrayGetElementSize(sac.Array)
}

func (sac *SafeArrayConversion) TotalElements(index uint32) (totalElements int32, err error) {
        if index < 1 {
                index = 1
        }

        // Get array bounds
        var LowerBounds int32
        var UpperBounds int32

        LowerBounds, err = safeArrayGetLBound(sac.Array, index)
        if err != nil {
                return
        }

        UpperBounds, err = safeArrayGetUBound(sac.Array, index)
        if err != nil {
                return
        }

        totalElements = UpperBounds - LowerBounds + 1
        return
}

// Release Safe Array memory
func (sac *SafeArrayConversion) Release() {
        safeArrayDestroy(sac.Array)
}

package ole

import (
        "unicode/utf16"
        "unsafe"
)

// ClassIDFrom retrieves class ID whether given is program ID or application string.
//
// Helper that provides check against both Class ID from Program ID and Class ID from string. It is
// faster, if you know which you are using, to use the individual functions, but this will check
// against available functions for you.
func ClassIDFrom(programID string) (classID *GUID, err error) {
        classID, err = CLSIDFromProgID(programID)
        if err != nil {
                classID, err = CLSIDFromString(programID)
                if err != nil {
                        return
                }
        }
        return
}

// BytePtrToString converts byte pointer to a Go string.
func BytePtrToString(p *byte) string {
        a := (*[10000]uint8)(unsafe.Pointer(p))
        i := 0
        for a[i] != 0 {
                i++
        }
        return string(a[:i])
}

// UTF16PtrToString is alias for LpOleStrToString.
//
// Kept for compatibility reasons.
func UTF16PtrToString(p *uint16) string {
        return LpOleStrToString(p)
}

// LpOleStrToString converts COM Unicode to Go string.
func LpOleStrToString(p *uint16) string {
        if p == nil {
                return ""
        }

        length := lpOleStrLen(p)
        a := make([]uint16, length)

        ptr := unsafe.Pointer(p)

        for i := 0; i < int(length); i++ {
                a[i] = *(*uint16)(ptr)
                ptr = unsafe.Pointer(uintptr(ptr) + 2)
        }

        return string(utf16.Decode(a))
}

// BstrToString converts COM binary string to Go string.
func BstrToString(p *uint16) string {
        if p == nil {
                return ""
        }
        length := SysStringLen((*int16)(unsafe.Pointer(p)))
        a := make([]uint16, length)

        ptr := unsafe.Pointer(p)

        for i := 0; i < int(length); i++ {
                a[i] = *(*uint16)(ptr)
                ptr = unsafe.Pointer(uintptr(ptr) + 2)
        }
        return string(utf16.Decode(a))
}

// lpOleStrLen returns the length of Unicode string.
func lpOleStrLen(p *uint16) (length int64) {
        if p == nil {
                return 0
        }

        ptr := unsafe.Pointer(p)

        for i := 0; ; i++ {
                if 0 == *(*uint16)(ptr) {
                        length = int64(i)
                        break
                }
                ptr = unsafe.Pointer(uintptr(ptr) + 2)
        }
        return
}

// convertHresultToError converts syscall to error, if call is unsuccessful.
func convertHresultToError(hr uintptr, r2 uintptr, ignore error) (err error) {
        if hr != 0 {
                err = NewError(hr)
        }
        return
}

package ole

import "unsafe"

// NewVariant returns new variant based on type and value.
func NewVariant(vt VT, val int64) VARIANT {
        return VARIANT{VT: vt, Val: val}
}

// ToIUnknown converts Variant to Unknown object.
func (v *VARIANT) ToIUnknown() *IUnknown {
        if v.VT != VT_UNKNOWN {
                return nil
        }
        return (*IUnknown)(unsafe.Pointer(uintptr(v.Val)))
}

// ToIDispatch converts variant to dispatch object.
func (v *VARIANT) ToIDispatch() *IDispatch {
        if v.VT != VT_DISPATCH {
                return nil
        }
        return (*IDispatch)(unsafe.Pointer(uintptr(v.Val)))
}

// ToArray converts variant to SafeArray helper.
func (v *VARIANT) ToArray() *SafeArrayConversion {
        if v.VT != VT_SAFEARRAY {
                if v.VT&VT_ARRAY == 0 {
                        return nil
                }
        }
        var safeArray *SafeArray = (*SafeArray)(unsafe.Pointer(uintptr(v.Val)))
        return &SafeArrayConversion{safeArray}
}

// ToString converts variant to Go string.
func (v *VARIANT) ToString() string {
        if v.VT != VT_BSTR {
                return ""
        }
        return BstrToString(*(**uint16)(unsafe.Pointer(&v.Val)))
}

// Clear the memory of variant object.
func (v *VARIANT) Clear() error {
        return VariantClear(v)
}

// Value returns variant value based on its type.
//
// Currently supported types: 2- and 4-byte integers, strings, bools.
// Note that 64-bit integers, datetimes, and other types are stored as strings
// and will be returned as strings.
//
// Needs to be further converted, because this returns an interface{}.
func (v *VARIANT) Value() interface{} {
        switch v.VT {
        case VT_I1:
                return int8(v.Val)
        case VT_UI1:
                return uint8(v.Val)
        case VT_I2:
                return int16(v.Val)
        case VT_UI2:
                return uint16(v.Val)
        case VT_I4:
                return int32(v.Val)
        case VT_UI4:
                return uint32(v.Val)
        case VT_I8:
                return int64(v.Val)
        case VT_UI8:
                return uint64(v.Val)
        case VT_INT:
                return int(v.Val)
        case VT_UINT:
                return uint(v.Val)
        case VT_INT_PTR:
                return uintptr(v.Val) // TODO
        case VT_UINT_PTR:
                return uintptr(v.Val)
        case VT_R4:
                return *(*float32)(unsafe.Pointer(&v.Val))
        case VT_R8:
                return *(*float64)(unsafe.Pointer(&v.Val))
        case VT_BSTR:
                return v.ToString()
        case VT_DATE:
                // VT_DATE type will either return float64 or time.Time.
                d := uint64(v.Val)
                date, err := GetVariantDate(d)
                if err != nil {
                        return float64(v.Val)
                }
                return date
        case VT_UNKNOWN:
                return v.ToIUnknown()
        case VT_DISPATCH:
                return v.ToIDispatch()
        case VT_BOOL:
                return (v.Val & 0xffff) != 0
        }
        return nil
}

// generated by stringer -output vt_string.go -type VT; DO NOT EDIT

package ole

import "fmt"

const (
        _VT_name_0 = "VT_EMPTYVT_NULLVT_I2VT_I4VT_R4VT_R8VT_CYVT_DATEVT_BSTRVT_DISPATCHVT_ERRORVT_BOOLVT_VARIANTVT_UNKNOWNVT_DECIMAL"
        _VT_name_1 = "VT_I1VT_UI1VT_UI2VT_UI4VT_I8VT_UI8VT_INTVT_UINTVT_VOIDVT_HRESULTVT_PTRVT_SAFEARRAYVT_CARRAYVT_USERDEFINEDVT_LPSTRVT_LPWSTR"
        _VT_name_2 = "VT_RECORDVT_INT_PTRVT_UINT_PTR"
        _VT_name_3 = "VT_FILETIMEVT_BLOBVT_STREAMVT_STORAGEVT_STREAMED_OBJECTVT_STORED_OBJECTVT_BLOB_OBJECTVT_CFVT_CLSID"
        _VT_name_4 = "VT_BSTR_BLOBVT_VECTOR"
        _VT_name_5 = "VT_ARRAY"
        _VT_name_6 = "VT_BYREF"
        _VT_name_7 = "VT_RESERVED"
        _VT_name_8 = "VT_ILLEGAL"
)

var (
        _VT_index_0 = [...]uint8{0, 8, 15, 20, 25, 30, 35, 40, 47, 54, 65, 73, 80, 90, 100, 110}
        _VT_index_1 = [...]uint8{0, 5, 11, 17, 23, 28, 34, 40, 47, 54, 64, 70, 82, 91, 105, 113, 122}
        _VT_index_2 = [...]uint8{0, 9, 19, 30}
        _VT_index_3 = [...]uint8{0, 11, 18, 27, 37, 55, 71, 85, 90, 98}
        _VT_index_4 = [...]uint8{0, 12, 21}
        _VT_index_5 = [...]uint8{0, 8}
        _VT_index_6 = [...]uint8{0, 8}
        _VT_index_7 = [...]uint8{0, 11}
        _VT_index_8 = [...]uint8{0, 10}
)

func (i VT) String() string {
        switch {
        case 0 <= i && i <= 14:
                return _VT_name_0[_VT_index_0[i]:_VT_index_0[i+1]]
        case 16 <= i && i <= 31:
                i -= 16
                return _VT_name_1[_VT_index_1[i]:_VT_index_1[i+1]]
        case 36 <= i && i <= 38:
                i -= 36
                return _VT_name_2[_VT_index_2[i]:_VT_index_2[i+1]]
        case 64 <= i && i <= 72:
                i -= 64
                return _VT_name_3[_VT_index_3[i]:_VT_index_3[i+1]]
        case 4095 <= i && i <= 4096:
                i -= 4095
                return _VT_name_4[_VT_index_4[i]:_VT_index_4[i+1]]
        case i == 8192:
                return _VT_name_5
        case i == 16384:
                return _VT_name_6
        case i == 32768:
                return _VT_name_7
        case i == 65535:
                return _VT_name_8
        default:
                return fmt.Sprintf("VT(%d)", i)
        }
}

// +build !windows

package ole

// RoInitialize
func RoInitialize(thread_type uint32) (err error) {
        return NewError(E_NOTIMPL)
}

// RoActivateInstance
func RoActivateInstance(clsid string) (ins *IInspectable, err error) {
        return nil, NewError(E_NOTIMPL)
}

// RoGetActivationFactory
func RoGetActivationFactory(clsid string, iid *GUID) (ins *IInspectable, err error) {
        return nil, NewError(E_NOTIMPL)
}

// HString is handle string for pointers.
type HString uintptr

// NewHString returns a new HString for Go string.
func NewHString(s string) (hstring HString, err error) {
        return HString(uintptr(0)), NewError(E_NOTIMPL)
}

// DeleteHString deletes HString.
func DeleteHString(hstring HString) (err error) {
        return NewError(E_NOTIMPL)
}

// String returns Go string value of HString.
func (h HString) String() string {
        return ""
}