/*

    ......... 2015 Ivan Mahonin

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

using System;

namespace Contours {

    public class Circuit<Parent, Child> where Parent: class where Child: class {

        public class Entry {

            readonly Child owner;

            Circuit<Parent, Child> circuit;

            Entry previous;

            Entry next;

            public Entry(Child owner) { this.owner = owner; }

            public Child getOwner() { return owner; }

            public Circuit<Parent, Child> getCircuit() { return circuit; }

            public Parent getParent() {

                Circuit<Parent, Child> circuit = getCircuit();

                return circuit == null ? null : circuit.getOwner();

            }

            public Entry getPreviousEntry() { return previous; }

            public Entry getNextEntry() { return next; }

            public Entry getPreviousEntryLinear() {

                Entry e = getPreviousEntry();

                return e == null || e == circuit.last ? null : e;

            }

            public Entry getNextEntryLinear() {

                Entry e = getNextEntry();

                return e == null || e == circuit.first ? null : e;

            }

            public Child getPrevious() {

                Entry e = getPreviousEntry();

                return e == null ? null : e.getOwner();

            }

            public Child getNext() {

                Entry e = getNextEntry();

                return e == null ? null : e.getOwner();

            }

            public Child getPreviousLinear() {

                Entry e = getPreviousEntryLinear();

                return e == null ? null : e.getOwner();

            }

            public Child getNextLinear() {

                Entry e = getNextEntryLinear();

                return e == null ? null : e.getOwner();

            }

            public void unlink() {

                if (previous != null) previous.next = next;

                if (next != null) next.previous = previous;

                if (circuit != null) {

                    if (circuit.first == this) {

                        circuit.first = next != this ? next : null;

                        circuit.last = previous != this ? previous : null;

                    }

                    --circuit.count;

                    circuit = null;

                }

                previous = null;

                next = null;

            }

            public void insertBack(Circuit<Parent, Child> circuit) {

                unlink();

                if (circuit != null) {

                    if (circuit.empty()) {

                        this.circuit = circuit;

                        previous = next = this;

                        circuit.first = circuit.last = this;

                        ++circuit.count;

                    } else {

                        insertAfterOf(circuit.getLastEntry());

                    }

                }

            }

            public void insertFront(Circuit<Parent, Child> circuit) {

                unlink();

                if (circuit != null) {

                    if (circuit.empty()) {

                        this.circuit = circuit;

                        previous = next = this;

                        circuit.first = circuit.last = this;

                        ++circuit.count;

                    } else {

                        insertBeforeOf(circuit.getFirstEntry());

                    }

                }

            }

            public void insertAfterOf(Entry entry) {

                if (entry == this) return;

                unlink();

                if (entry == null || entry.getCircuit() == null) return;

                previous = entry;

                next = entry.next;

                previous.next = this;

                if (next != null) next.previous = this;

                circuit = entry.getCircuit();

                if (circuit != null) {

                    if (circuit.getLastEntry() == entry)

                        circuit.last = this;

                    ++circuit.count;

               }

            }

            public void insertBeforeOf(Entry entry) {

                if (entry == this) return;

                unlink();

                if (entry == null || entry.getCircuit() == null) return;

                previous = entry.previous;

                next = entry;

                if (previous != null) previous.next = this;

                next.previous = this;

                circuit = entry.getCircuit();

                if (circuit != null) {

                    if (circuit.getFirstEntry() == entry)

                        circuit.first = this;

                    ++circuit.count;

                }

            }

            public void swapWith(Entry other) {

                if (other == this || other == null) return;

                if (this.next == other || other.previous == this) {

                    this.next = other.next;

                    other.next.previous = this;

                    other.previous = this.previous;

                    this.previous.next = other;

                    this.previous = other;

                    other.next = this;

                    return;

                }

                if (other.next == this || this.previous == other) {

                    other.next = this.next;

                    this.next.previous = other;

                    this.previous = other.previous;

                    other.previous.next = this;

                    other.previous = this;

                    this.next = other;

                    return;

                }

                if (other.circuit != null) {

                    if (other.circuit.first == other)

                        other.circuit.first = this;

                    if (other.circuit.last == other)

                        other.circuit.last = this;

                }

                if (this.circuit != null) {

                    if (this.circuit.first == this)

                        this.circuit.first = other;

                    if (this.circuit.last == this)

                        this.circuit.last = other;

                }

                Circuit<Parent, Child> otherCircuit = other.circuit;

                Entry otherPrevious = other.previous;

                Entry otherNext = other.next;

                other.circuit = this.circuit;

                other.previous = this.previous;

                other.next = this.next;

                this.circuit = otherCircuit;

                this.previous = otherPrevious;

                this.next = otherNext;

                if (other.previous != null) other.previous.next = other;

                if (other.next != null) other.next.previous = other;

                if (this.previous != null) this.previous.next = this;

                if (this.next != null) this.next.previous = this;

            }

            public static void swapChains(Circuit<Parent, Child> a, Circuit<Parent, Child> b) {

                for(Entry e = a.getFirstEntry(); e != null; e = e.getNextEntryLinear())

                    e.circuit = b;

                for(Entry e = b.getFirstEntry(); e != null; e = e.getNextEntryLinear())

                    e.circuit = a;

            }

        }

        readonly Parent owner;

        Entry first;

        Entry last;

        int count = 0;

        public Circuit(Parent owner) { this.owner = owner; }

        public Parent getOwner() { return owner; }

        public int getCount() { return count; }

        public Entry getFirstEntry() { return first; }

        public Entry getLastEntry() { return last; }

        public Child getFirst() {

            Entry e = getFirstEntry();

            return e == null ? null : e.getOwner();

        }

        public Child getLast() {

            Entry e = getLastEntry();

            return e == null ? null : e.getOwner();

        }

        public bool empty() { return getFirstEntry() == null; }

        public void clear() {

            while(!empty()) getFirstEntry().unlink();

        }

        public void swapWith(Circuit<Parent, Child> other) {

            Entry.swapChains(this, other);

        }

    }

}