//
//  Array_gp.c
//  algorithm
//
//  Created by wangbinbin on 2019/1/10.
//  Copyright © 2019 wangbinbin. All rights reserved.
//

#include "Array_gp.h"
#include <string.h>
#include <stdbool.h>
// 创建数组
Array* arrayCreate()
{
    struct Array *array = NULL;
    // 给 array 分配内存
    array = malloc(sizeof(*array));
    if (NULL == array)
    {
        return NULL;
    }
    
    // 初始化 array 内的元素
    array->p = NULL;
    
    array->size = 0;
    array->typeSize = 0;
    array->len = 0;
    
    array->dup = NULL;
    array->free = NULL;
    array->match = NULL;
    
    return array;
}

// 初始化 数组
void arrayInit(Array *array, int size, int typeSize)
{
    if (NULL == array
        || typeSize <= 0
        || size < 0)
    {
        return;
    }
    
    void *p = calloc(1, size* typeSize);
    if (NULL == p)
    {
        return;
    }
    
    array->p = p;
    array->len = 0;
    array->size = size;
    array->typeSize = typeSize;
}

int arrayInsert(Array *array, size_t pos, void *const value)
{
    // 异常处理
    if (NULL == array) // 数组为空
// 数组插入数据
    {
        return -1;
    }
    
    if (array->len >= array->size) // 数组已满
    {
        return -2;
    }
    
    if (pos > array->size || pos <= 0)// 数组越界
    { 
        return -3;
    }
    // 拿到数组起始指针地址

    char *pBegin = array->p;
    for (size_t i = array->len; i > pos - 1; --i)
    {
        void *pNew = pBegin + i * array->typeSize;
        void *pOld = pBegin + (i - 1) *array->typeSize;
        if (NULL != array->dup)
        {
            array->dup(pNew, pOld);
        }
        else
        {
            memcpy(pNew, pOld, array->typeSize);
        }
    }
    
    void *pCopy = (void*)(pBegin + ((pos - 1) * array->typeSize));
    if (NULL != array->dup)
    {
        array->dup(pCopy, value);
    }
    else
    {
        memcpy(pCopy, value, array->typeSize);
    }
    ++array->len;
    return 0;
}

size_t arraySearchValue(Array *array, void* const value)
{
    if (NULL == array)
    {
        return -1;
    }
    
    char *pBegin = array->p;
    size_t i = 0;
    for (; i < array->len; ++i)
    {
        int nCmp = 0;
        if (NULL != array->match)
        {
            nCmp = array->match(pBegin + i * array->typeSize, value);
        }
        else
        {
            nCmp = memcmp(pBegin + i * array->typeSize, value, array->typeSize);
        }
        
        if (nCmp == 0)
        {
            break;
        }
    }
    
    return i;
}

void* arrayIndex(Array *array, size_t index)
{
    if (NULL == array)
    {
        return NULL;
    }
    
    if (index > array->len
        || index <= 0)
    {
        return NULL;
    }
    
    char *pBegin = array->p;
    return pBegin + array->typeSize * (index - 1);
}

int arrayModify(Array *array, size_t pos, void *const value)
{
    if (NULL == array)
    {
        return -1;
    }
    if (pos > array->len
        || pos <= 0)
    {
        return -2;
    }
    
    char *pBegin = array->p;
    void *pOld = pBegin + (pos - 1) * array->typeSize;
    if (NULL != array->dup)
    {
        array->dup(pOld, value);
    }
    else
    {
        memcpy(pOld, value, array->typeSize);
    }
    
    return 0;
}

size_t arrayLen(Array *array)
{
    if (NULL == array)
    {
        return 0;
    }
    
    return array->len;
}

size_t arraySize(Array *array)
{
    if (NULL == array)
    {
        return 0;
    }
    
    return array->size;
}

void arrayEmpty(Array *array)
{
    if (NULL == array)
    {
        return;
    }
    
    free(array->p);
    array->p = NULL;
    free(array);
    array = NULL;
}

void arrayDelValue(Array *array, void *value)
{
    if (NULL == array)
    {
        return;
    }
    
    char* pBegin = array->p;
    bool bCopy = false;
    for (size_t i = 0; i < array->len; ++i)
    {
        if (!bCopy)
        {
            int nCmp = 0;
            if (NULL != array->match)
            {
                nCmp = array->match(pBegin + i * array->typeSize, value);
            }
            else
            {
                nCmp = memcmp(pBegin + i * array->typeSize, value, array->typeSize);
            }
            
            if (0 == nCmp)
            {
                bCopy = true;
                continue;
            }
        }
        else
        {
            void *pOld = pBegin + (i + 1) * array->typeSize;
            void *pNew = pBegin + i * array->typeSize;
            if (NULL != array->dup)
            {
                array->dup(pNew, pOld);
            }
            else
            {
                memcpy(pNew, pOld, array->typeSize);
            }
        }
    }
    
    if (bCopy)
    {
        --array->len;
    }
}

void arrayDelIndex(Array *array, size_t pos)
{
    if (NULL == array)
    {
        return;
    }
    
    if (pos > array->len || pos <= 0)
    {
        return;
    }
    
    char* pBegin = array->p;
    for (size_t i = pos - 1; i < array->len - 1; ++i)
    {
        void *pOld = pBegin + (i + 1) * array->typeSize;
        void *pNew = pBegin + i * array->typeSize;
        if (NULL != array->dup)
        {
            array->dup(pNew, pOld);
        }
        else
        {
            memcpy(pNew, pOld, array->typeSize);
        }
    }
    
    --array->len;
}

void dumpArr(struct Array *array)
{
    int idx;
    
    for (idx = 0; idx < array->len; idx++){
        int *t = array->p;
        printf("[%02d]: %08d\n", idx, t[idx]);
    }
    
}


int testFunctionArray()
{
    Array *array = arrayCreate();
    arrayInit(array, 8, 8);
    int num1 = 100;
    const int *a = &num1;
    arrayInsert(array, 1, a);
    dumpArr(array);
    return 0;
}