package ca.uhn.fhir.model.api;

import static org.apache.commons.lang3.StringUtils.isBlank;
import static org.apache.commons.lang3.StringUtils.isNotBlank;

import org.apache.commons.lang3.builder.ToStringBuilder;

/*
 * #%L
 * HAPI FHIR - Core Library
 * %%
 * Copyright (C) 2014 - 2016 University Health Network
 * %%
 * 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.
 * #L%
 */

/**
 * Represents a FHIR resource path specification, e.g. <code>Patient:name</code>
 * <p>
 * Note on equality: This class uses {@link #getValue() value} and the {@link #isRecurse() recurse} properties to test
 * equality. Prior to HAPI 1.2 (and FHIR DSTU2) the recurse property did not exist, so this may merit consideration when
 * upgrading servers.
 * </p>
 */
public class Include {

        private final boolean myImmutable;
        private boolean myRecurse;
        private String myValue;

        /**
         * Constructor for <b>non-recursive</b> include
         * 
         * @param theValue
         *           The <code>_include</code> value, e.g. "Patient:name"
         */
        public Include(String theValue) {
                myValue = theValue;
                myImmutable = false;
        }

        /**
         * Constructor for an include
         * 
         * @param theValue
         *           The <code>_include</code> value, e.g. "Patient:name"
         * @param theRecurse
         *           Should the include recurse
         */
        public Include(String theValue, boolean theRecurse) {
                myValue = theValue;
                myRecurse = theRecurse;
                myImmutable = false;
        }

        /**
         * Constructor for an include
         * 
         * @param theValue
         *           The <code>_include</code> value, e.g. "Patient:name"
         * @param theRecurse
         *           Should the include recurse
         */
        public Include(String theValue, boolean theRecurse, boolean theImmutable) {
                myValue = theValue;
                myRecurse = theRecurse;
                myImmutable = theImmutable;
        }

        /**
         * Creates a copy of this include with non-recurse behaviour
         */
        public Include asNonRecursive() {
                return new Include(myValue, false);
        }

        /**
         * Creates a copy of this include with recurse behaviour
         */
        public Include asRecursive() {
                return new Include(myValue, true);
        }

        /**
         * See the note on equality on the {@link Include class documentation}
         */
        @Override
        public boolean equals(Object obj) {
                if (this == obj) {
                        return true;
                }
                if (obj == null) {
                        return false;
                }
                if (getClass() != obj.getClass()) {
                        return false;
                }
                Include other = (Include) obj;
                if (myRecurse != other.myRecurse) {
                        return false;
                }
                if (myValue == null) {
                        if (other.myValue != null) {
                                return false;
                        }
                } else if (!myValue.equals(other.myValue)) {
                        return false;
                }
                return true;
        }

        /**
         * Returns the portion of the value before the first colon
         */
        public String getParamType() {
                int firstColon = myValue.indexOf(':');
                if (firstColon == -1 || firstColon == myValue.length() - 1) {
                        return null;
                }
                return myValue.substring(0, firstColon);
        }

        /**
         * Returns the portion of the value after the first colon but before the second colon
         */
        public String getParamName() {
                int firstColon = myValue.indexOf(':');
                if (firstColon == -1 || firstColon == myValue.length() - 1) {
                        return null;
                }
                int secondColon = myValue.indexOf(':', firstColon + 1);
                if (secondColon != -1) {
                        return myValue.substring(firstColon + 1, secondColon);
                } else {
                        return myValue.substring(firstColon + 1);
                }
        }

        /**
         * Returns the portion of the string after the second colon, or null if there are not two colons in the value.
         */
        public String getParamTargetType() {
                int firstColon = myValue.indexOf(':');
                if (firstColon == -1 || firstColon == myValue.length() - 1) {
                        return null;
                }
                int secondColon = myValue.indexOf(':', firstColon + 1);
                if (secondColon != -1) {
                        return myValue.substring(secondColon + 1);
                } else {
                        return null;
                }

        }

        public String getValue() {
                return myValue;
        }

        /**
         * See the note on equality on the {@link Include class documentation}
         */
        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + (myRecurse ? 1231 : 1237);
                result = prime * result + ((myValue == null) ? 0 : myValue.hashCode());
                return result;
        }

        /**
         * Is this object {@link #toLocked() locked}?
         */
        public boolean isLocked() {
                return myImmutable;
        }

        public boolean isRecurse() {
                return myRecurse;
        }

        public void setRecurse(boolean theRecurse) {
                myRecurse = theRecurse;
        }

        public void setValue(String theValue) {
                if (myImmutable) {
                        throw new IllegalStateException("Can not change the value of this include");
                }
                myValue = theValue;
        }

        /**
         * Return a new
         */
        public Include toLocked() {
                Include retVal = new Include(myValue, myRecurse, true);
                return retVal;
        }

        @Override
        public String toString() {
                ToStringBuilder builder = new ToStringBuilder(this);
                builder.append("value", myValue);
                builder.append("recurse", myRecurse);
                return builder.toString();
        }

        /**
         * Creates and returns a new copy of this Include with the given type. The following table shows what will be
         * returned:
         * <table>
         * <tr>
         * <th>Initial Contents</th>
         * <th>theResourceType</th>
         * <th>Output</th>
         * </tr>
         * <tr>
         * <td>Patient:careProvider</th>
         * <th>Organization</th>
         * <th>Patient:careProvider:Organization</th>
         * </tr>
         * <tr>
         * <td>Patient:careProvider:Practitioner</th>
         * <th>Organization</th>
         * <th>Patient:careProvider:Organization</th>
         * </tr>
         * <tr>
         * <td>Patient</th>
         * <th>(any)</th>
         * <th>{@link IllegalStateException}</th>
         * </tr>
         * </table>
         * 
         * @param theResourceType
         *           The resource type (e.g. "Organization")
         * @return A new copy of the include. Note that if this include is {@link #toLocked() locked}, the returned include
         *         will be too
         */
        public Include withType(String theResourceType) {
                StringBuilder b = new StringBuilder();
                
                String paramType = getParamType();
                String paramName = getParamName();
                if (isBlank(paramType) || isBlank(paramName)) {
                        throw new IllegalStateException("This include does not contain a value in the format [ResourceType]:[paramName]");
                }
                b.append(paramType);
                b.append(":");
                b.append(paramName);
                
                if (isNotBlank(theResourceType)) {
                        b.append(':');
                        b.append(theResourceType);
                }
                Include retVal = new Include(b.toString(), myRecurse, myImmutable);
                return retVal;
        }

}