/**
 * Copyright 2005-2015 The Kuali Foundation
 *
 * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
 *
 * 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.
 */
package org.kuali.rice.kim.impl.common;

import org.junit.Before;
import org.junit.Test;
import org.kuali.rice.kim.api.common.attribute.KimAttribute;
import org.kuali.rice.kim.api.common.attribute.KimAttributeContract;
import org.kuali.rice.kim.api.type.KimType;
import org.kuali.rice.kim.api.type.KimTypeAttributeContract;
import org.kuali.rice.kim.api.type.KimTypeContract;
import org.kuali.rice.kim.api.type.KimTypeInfoService;
import org.kuali.rice.kim.impl.common.attribute.KimAttributeDataBo;
import org.kuali.rice.kim.impl.group.GroupAttributeBo;
import org.kuali.rice.kim.impl.type.KimTypeBo;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static org.junit.Assert.*;
import static org.mockito.Mockito.*;


public class KimAttributeDataBoTest {

    private static KimTypeContract mockKimTypeContract;
    private static KimAttributeContract mockKimAttributeContract;

    private KimTypeInfoService mockInfoService;

    private static KimType create() {
        return KimType.Builder.create(mockKimTypeContract).build();
    }

    private static KimAttribute createKimAttribute() {
        return KimAttribute.Builder.create(mockKimAttributeContract).build();
    }

    @Before
    public void setup() throws Exception {

        mockKimAttributeContract = mock(KimAttributeContract.class);
        {
            Long versionNumber = 1L;
            String attributeName = "one";
            String namespaceCode = "namespaceCode";
            String id = "id_one";
            when( mockKimAttributeContract.getVersionNumber()).thenReturn(versionNumber);
            when( mockKimAttributeContract.getAttributeName()).thenReturn(attributeName);
            when( mockKimAttributeContract.getNamespaceCode()).thenReturn(namespaceCode);
            when( mockKimAttributeContract.getId() ).thenReturn(id);
        }

        KimTypeAttributeContract one = mock(KimTypeAttributeContract.class);
        {
            String id = "one";
            Long versionNumber = 1L;
            KimAttribute attribute = createKimAttribute();
            when(one.getKimAttribute()).thenReturn(attribute);
            when(one.getId()).thenReturn(id);
            when(one.getVersionNumber()).thenReturn(versionNumber);
        }


        mockKimTypeContract = mock(KimTypeContract.class);
        {
            String id = new String("27");
            String serviceName = "barService";
            String namespaceCode ="NAMESPACE CODE";
            String name = "mock Kim Type Contract";
            Long versionNumber = 1L;
            String objectId = "1";
            List attributeDefinitions = new ArrayList<KimTypeAttributeContract>();
            attributeDefinitions.add(one);
            when(mockKimTypeContract.getId()).thenReturn(id);
            when(mockKimTypeContract.getServiceName()).thenReturn(serviceName);
            when(mockKimTypeContract.getNamespaceCode()).thenReturn(namespaceCode);
            when(mockKimTypeContract.getName()).thenReturn(name);
            when(mockKimTypeContract.getVersionNumber()).thenReturn(versionNumber);
            when(mockKimTypeContract.getObjectId()).thenReturn(objectId);
            when(mockKimTypeContract.getAttributeDefinitions()).thenReturn(attributeDefinitions);
        }

        KimType kimType = create();
        mockInfoService = mock(KimTypeInfoService.class);
        {
            when( mockInfoService.getKimType(anyString()) ).thenReturn(kimType);
        }

    }

    @Test
    public void testKimAttributeDataBo() {
        KimType kimType = create();
        Map<String,String> attributes = new HashMap<String,String>(); //{organizationCode=COMP, chartOfAccountsCode=BL}
        attributes.put("one","one");

        String kimTypeId = "27";

        assertEquals(kimType.getId(), "27");

        KimAttributeDataBo.setKimTypeInfoService(mockInfoService);

        GroupAttributeBo groupQualifier = KimAttributeDataBo.createFrom(GroupAttributeBo.class, attributes, kimTypeId).get(0);

        assertNotNull(groupQualifier.getKimType());
        assertEquals(groupQualifier.getKimType().getId(), KimTypeBo.from(kimType).getId());

    }

}