/*
 *  Licensed to GraphHopper GmbH under one or more contributor
 *  license agreements. See the NOTICE file distributed with this work for
 *  additional information regarding copyright ownership.
 *
 *  GraphHopper GmbH licenses this file to you 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.
 */

package com.graphhopper.reader.gtfs;

import com.graphhopper.reader.ReaderRelation;
import com.graphhopper.reader.ReaderWay;
import com.graphhopper.routing.util.AbstractFlagEncoder;
import com.graphhopper.routing.util.EncodedDoubleValue;
import com.graphhopper.routing.util.EncodedValue;
import com.graphhopper.routing.util.FootFlagEncoder;

public class PtFlagEncoder extends AbstractFlagEncoder {

	private final FootFlagEncoder footFlagEncoder;
	private EncodedValue time;
	private EncodedValue transfers;
	private EncodedValue validityId;
	private EncodedValue type;

	public PtFlagEncoder() {
		super(0, 1, 0);

		// I use the foot flag encoder only as a delegate to filter by OSM tags,
		// not to encode flags.
		footFlagEncoder = new FootFlagEncoder();
		// Still, I have to do this. Otherwise 'acceptWay' returns 0 even though
		// it wants to accept. Basically, I have to tell it what 'true' means.
		footFlagEncoder.defineWayBits(1, 0);
		footFlagEncoder.defineRelationBits(1, 0);
	}

	@Override
	public int defineWayBits(int index, int shift) {
		shift = super.defineWayBits(index, shift);

		// I have to set super.speedEncoder even though
		// super already knows speedBits and speedFactor because they are constructor parameters.
		speedEncoder = new EncodedDoubleValue("Speed", shift, speedBits, speedFactor, 0, 0);
		shift += speedEncoder.getBits();

		time = new EncodedValue("time", shift, 32, 1.0, 0, Integer.MAX_VALUE);
		shift += time.getBits();
		transfers = new EncodedValue("transfers", shift, 1, 1.0, 0, 1);
		shift += transfers.getBits();
		validityId = new EncodedValue("validityId", shift, 20, 1.0, 0, 1048575);
		shift += validityId.getBits();
		GtfsStorage.EdgeType[] edgeTypes = GtfsStorage.EdgeType.values();
		type = new EncodedValue("type", shift, 6, 1.0, GtfsStorage.EdgeType.HIGHWAY.ordinal(), edgeTypes[edgeTypes.length-1].ordinal());
		shift += type.getBits();
		return shift;
	}

	@Override
	public long handleRelationTags(ReaderRelation relation, long oldRelationFlags) {
		return footFlagEncoder.handleRelationTags(relation, oldRelationFlags);
	}

	@Override
	public long acceptWay(ReaderWay way) {
		return footFlagEncoder.acceptWay(way);
	}

	@Override
	public long handleWayTags(ReaderWay way, long allowed, long relationFlags) {
		return footFlagEncoder.handleWayTags(way, allowed, relationFlags);
	}

	long getTime(long flags) {
        return time.getValue(flags);
    }

    long setTime(long flags, long time) {
        return this.time.setValue(flags, time);
    }

    int getTransfers(long flags) {
		return (int) transfers.getValue(flags);
	}

	long setTransfers(long flags, int transfers) {
		return this.transfers.setValue(flags, transfers);
	}

	int getValidityId(long flags) {
		return (int) validityId.getValue(flags);
	}

	long setValidityId(long flags, int validityId) {
		return this.validityId.setValue(flags, validityId);
	}

	GtfsStorage.EdgeType getEdgeType(long flags) {
		return GtfsStorage.EdgeType.values()[(int) type.getValue(flags)];
	}

	long setEdgeType(long flags, GtfsStorage.EdgeType edgeType) {
		return type.setValue(flags, edgeType.ordinal());
	}

	public String toString() {
		return "pt";
	}

	@Override
	public int getVersion() {
		return 0;
	}
}