abstract class HierarchicalModel extends Model
{
    protected static string $sortChildrenBy;

    /**
     * Get the parent model of the model.
     */
    public function parent()
    {
        return $this->belongsTo(static::class, 'parent_id');
    }

    /**
     * Get the child models of the model.
     */
    public function children()
    {
        $relations = $this->hasMany(static::class, 'parent_id');
        $relations->orderBy('set_start', 'ASC');
        return $relations;
    }

    /**
     * Determine if a model has any child model.
     */
    public function hasChild()
    {
        return $this->set_end - $this->set_start > 1;
    }

    /**
     * Get the ids of all descedants of the current model
     */
    public function getDescendantsAttribute()
    {
        return static::where('set_start', '>', $this->set_start)
            ->where('set_end', '<', $this->set_end)
            ->orderBy('set_start', 'asc')
            ->get();
    }

    /**
     * Get the ancestry of the current model
     */
    public function getAncestorsBottomUpAttribute()
    {
        return static::where('set_start', '<', $this->set_start)
            ->where('set_end', '>', $this->set_end)
            ->orderBy('set_start', 'desc')
            ->get();
    }

    /**
     * Get the ancestry of the current model
     */
    public function getAncestorsAttribute()
    {
        return static::where('set_start', '<', $this->set_start)
            ->where('set_end', '>', $this->set_end)
            ->orderBy('set_start', 'asc')
            ->get();
    }

    /**
     * Get the siblings of the current model
     */
    public function getSiblingsAttribute()
    {
        if (empty($this->parent_id)) {
            return static::whereNull('parent_id')->get();
        }
        return $this->parent->children;
    }

    /**
     * Deals with hierarchical model and nested set specific functionality
     * Then calls the parent save method.
     *
     * @return bool
     */
    public function save(array $options = []): bool
    {
        try {
            /* If necessary, the nested set start and end values */
            if ($this->isDirty(['parent_id', static::$sortChildrenBy])) {
                $sortChildrenBy = static::$sortChildrenBy;

                /* Find the next sibling of the new position of this node */
                if (empty($this->parent_id)) {
                    $baseQuery = static::whereNull('parent_id');
                    $this->depth = 1;
                } else {
                    $baseQuery = static::where('parent_id', $this->parent_id);
                    $this->depth = $this->parent->depth;
                }
                $nextSibling = $baseQuery->where($sortChildrenBy, '>', $this->$sortChildrenBy)->first();

                /*
                 * If updating, move the node (and any descendants).
                 * If adding, make space in the set for the new node
                 */
                if ($this->exists) {
                    /* Determine the new position of the moved node(s) */
                    if (empty($this->parent_id) && empty($nextSibling)) {
                        /* Move to be the last top level node */
                        $newEnd = static::max('set_end');
                    } else {
                        if (empty($nextSibling)) {
                            /* If we don't have a next sibling, we add as the last child of the parent */
                            $movingUp = $this->parent->set_end > $this->set_end;
                            if ($movingUp) {
                                $newEnd = $this->parent->set_end - 1;
                            } else {
                                $newStart = $this->parent->set_end;
                            }
                        } else {
                            $movingUp = $nextSibling->set_end > $this->set_end;
                            if ($movingUp) {
                                $newEnd = $nextSibling->set_start - 1;
                            } else {
                                $newStart = $nextSibling->set_start;
                            }
                        }
                    }
                    $width = $this->set_end - $this->set_start + 1;

                    if (isset($newEnd)) {
                        $newStart = $newEnd - $width + 1;
                    } else {
                        $newEnd = $newStart + $width - 1;
                    }

                    if ($newStart !== $this->set_start) {
                        /* Move the current node and descendants right out of the way. */
                        static::whereBetween('set_start', [$this->set_start, $this->set_end])
                            ->update([
                                'set_start' => DB::raw('set_start + 1000000'),
                                'set_end' => DB::raw('set_end + 1000000')
                            ]);

                        /* Adjust other nodes to make space for the moved subset */
                        $distance = $newStart - $this->set_start;
                        /**
                         * If distance is positive, we are moving up the set
                         * If we are moving up, we need to adjust all values between the old start and the new end.
                         * If we are moving down, we need to adjust all values between the new start and the old end.
                         */
                        if ($distance > 0) {
                            $rangeStart = $this->set_start;
                            $rangeEnd = $newEnd;
                            $adjustment = $width;
                        } else {
                            $rangeStart = $newStart;
                            $rangeEnd = $this->set_end;
                            $adjustment = $width * -1;
                        }
                        /* We substract the adjustment. If it is negative, it will increase the values of the other nodes */
                        static::whereBetween ('set_start', [$rangeStart, $rangeEnd])
                            ->update(['set_start' => DB::raw("set_start - $adjustment")]);
                        static::whereBetween ('set_end', [$rangeStart, $rangeEnd])
                            ->update(['set_end' => DB::raw("set_end - $adjustment")]);

                        /* Move the current node and descendants to its new location */
                        static::where('set_start', '>', 1000000)
                            ->update([
                                'set_start' => DB::raw("set_start - 1000000 + {$distance}"),
                                'set_end' => DB::raw("set_end - 1000000 + {$distance}")
                            ]);

                    }
                } else {
                    /* Inserting */
                    if (empty($this->parent_id) && empty($nextSibling)) {
                        /* Move to be the last top level node */
                        $newStart = static::max('set_end') + 1;
                    } else {
                        if (empty($nextSibling)) {
                            $newStart = $this->parent->set_end;
                        } else {
                            $newStart = $nextSibling->set_start;
                        }
                    }
                    $newEnd = $newStart + 1;
                    /* Make room for the new node */
                    static::where('set_start', '>=', $newStart)
                        ->update(['set_start' => DB::raw("set_start + 2")]);
                    static::where('set_end', '>=', $newStart)
                        ->update(['set_end' => DB::raw("set_end + 2")]);
                }
                $this->set_start = $newStart;
                $this->set_end = $newEnd;
            }
            return parent::save($options);

        } catch ( \Throwable $ex ) {
            Log::error($ex->getMessage());
            return false;
        }
    }

    public function delete() {
        $width = $this->set_end - $this->set_start + 1;
        /* Substract the width from all higher node values */
        static::where('set_start', '>', $this->set_start)
            ->update(['set_start' => DB::raw("set_start - $width")]);
        static::where('set_end', '>', $this->set_end)
            ->update(['set_end' => DB::raw("set_end - $width")]);
        parent::delete();
    }
}

class TreeView extends Component
{
    public string $modelName;
    public string $modelComponent;
    public string $target;
    public bool $multiSelect;
    public string $selectedItems;
    public int $root;

    private array $selectedItemsArray;

    public function __construct(string $modelName, string $modelComponent, string $target, bool $multiSelect = false, string $selectedItems = '', int $root = 0)
    {
        $this->modelName = $modelName;
        $this->modelComponent = $modelComponent;
        $this->target = $target;
        $this->multiSelect = $multiSelect;
        $this->selectedItems = $selectedItems;
        $this->selectedItemsArray = empty($selectedItems) ? [] : explode(',', $selectedItems);
        $this->root = $root;
    }

    public function render()
    {
        $modelClass = 'App\\Models\\' . $this->modelName;
        if ( empty($this->root) ) {
            $items = $modelClass::whereNull('parent_id')->get();
        } else {
            $items = $modelClass::where('parent_id', $this->root)->get();
        }
        if ( !empty($this->selectedItems) ) {
            $dependencies = [];
            foreach ($this->selectedItemsArray as $modelId) {
                $ancestorIds = array_values($modelClass::find($modelId)->ancestors->pluck('id')->toArray());
                $dependencies = array_merge($dependencies, $ancestorIds);
            }
            foreach ($items as $idx => $item) {
                $item->level = 1;
                $item->index = $idx;
                $this->getDependants($dependencies, $item, 2);
            }
        }
        return view('components.tree-view', ['items' => $items]);
    }

    private function getDependants($dependancies, $item, $level) {
        if ( in_array($item->id, $this->selectedItemsArray) ) {
            // We have got down to one of the selected items so do not need to go further
            $item->selected = true;
            return;
        }
        if ( in_array( $item->id, $dependancies) ) {
            $item->expanded = true;
            $item->childItems = $item->children;
            foreach ( $item->childItems as $child ) {
                $child->level = $level;
                $this->getDependants($dependancies, $child, $level + 1);
            }
        }
    }
}

class TreeViewItem extends Component
{
    public HierarchicalModel $item;
    public int $index;
    public int $level;
	public string $target;
    public string $modelComponent;
    public bool $hasChild;
    public bool $expanded;
    public bool $selected;
    public $children = null;

    protected $listeners = [
        'parentChanged' => 'refreshChildren',
        'refreshChildren' => 'refreshChildren',
        'move' => 'move',
    ];

    public function mount(string $modelComponent, HierarchicalModel $item, int $index=0, int $level=1, string $target='')
    {
        $this->item = $item;
        $this->index = $index;
        $this->level = isset($item->level) ? $item->level : $level;
        $this->target = $target;
        $this->modelComponent = $modelComponent;
        $this->hasChild = $this->item->hasChild();
        $this->expanded = isset($item->expanded) ? $item->expanded : false;
        $this->selected = isset($item->selected) ? $item->selected : false;
        $this->children = isset($item->childItems) ? $item->childItems : null;
    }

    public function render()
    {
        if ($this->expanded && $this->hasChild && empty( $this->children)) {
            if ($this->hasChild && $this->expanded && empty( $this->children)) {
                $this->children = $this->item->children;
            }
        }

        return view('livewire.tree-view-item');
    }

    public function refreshChildren($ids)
    {
        if (in_array($this->item->id, $ids, true)) {
            $this->children = $this->item->children;
            $this->hasChild = count($this->children) > 0;
        }
    }

    public function move(int $id, int $newSequenceNo)
    {
        if (
            empty($this->item->sequence_no) ||
            $this->item->id != $id ||
            $this->item->sequence_no === $newSequenceNo ||
            $newSequenceNo < 1
        ) {
            return;
        }
        // Get the siblings of the model (this includes the current model)
        $siblings = $this->item->siblings;
        if (count($siblings) <= 1 || $newSequenceNo > count($siblings)) {
            return;
        }
        /* As we only move one place at a time, we just need to swap positions */
        $movedItems = [['id' => $id, 'sequenceNo' => $newSequenceNo]];
        $parent_global_sequence = $this->item->parent->global_sequence;
        foreach ($siblings as $sibling) {
            if ($sibling->sequence_no != $newSequenceNo) {
                continue;
            }
            $sibling->sequence_no = $this->item->sequence_no;
            $sibling->global_sequence = $parent_global_sequence . '.' . $sibling->sequence_no;
            $sibling->save();
            $movedItems[]=['id' =>  $sibling->id, 'sequenceNo' => $sibling->sequence_no];
            break;
        }
        $this->item->sequence_no = $newSequenceNo;
        $this->item->global_sequence = $parent_global_sequence . '.' . $newSequenceNo;
        $this->item->save();
        $this->emitUp('refreshChildren', [$this->item->parent_id]);
        foreach ($movedItems as $movedItem) {
            $this->emit('sequenceChanged', $movedItem);
        }
    }
}

class CategoryListItem extends Component
{
    public ?CategoryModel $category;
    public int $sequenceNo;
    public int $maxSequenceNo;
    public bool $hasChild;
    public bool $showForm = false;
    public string $formComponent;

    protected $listeners = ['sequenceChanged', 'categoryFormSubmitCompleted'];

    public function mount(CategoryModel $category = null)
    {
        $this->category = $category;
        $this->sequenceNo = $category->sequence_no;
        $this->hasChild = $category->hasChild();

        $modelClass = get_class($this->category);
        if ( empty($this->category->parent_id) ) {
            $this->maxSequenceNo = $modelClass::whereNull('parent_id')->max('sequence_no');
        } else {
            $this->maxSequenceNo = $modelClass::find($this->category->parent_id)->next_sequence_no - 1;
        }
    }

    public function render()
    {
        return view('livewire.category-list-item');
    }

    public function sequenceChanged($args)
    {
        if ($this->category->id === $args['id']) {
            $this->sequenceNo = $args['sequenceNo'];
        }
    }

    public function categoryFormSubmitCompleted(int $id)
    {
        if ($this->category->id === $id) {
            $this->showForm = false;
        }
    }
}

public function delete(int $id)
{
    if ($this->item->id != $id || $this->item->hasChild()) {
        return;
    }
    $this->item->delete();
}

public function move(int $id, int $newSequenceNo): void
{
    if (
        empty($this->item->sequence_no) ||
        $this->item->id != $id ||
        $this->item->sequence_no === $newSequenceNo ||
        $newSequenceNo < 1
    ) {
        return;
    }
    // Get the siblings of the model (this includes the current model)
    $siblings = $this->item->siblings;
    if (count($siblings) <= 1 || $newSequenceNo > count($siblings)) {
        return;
    }
    /* As we only move one place at a time, we just need to swap positions */
    $movedItems = [['id' => $id, 'sequenceNo' => $newSequenceNo]];
    foreach ($siblings as $sibling) {
        if ($sibling->sequence_no != $newSequenceNo) {
            continue;
        }
        $movedItems[]=['id' => $sibling->id, 'sequenceNo' => $sibling->sequence_no];
        break;
    }
    $this->item->sequence_no = $newSequenceNo;

    DB::beginTransaction();
    try {
        $wasSavedSuccessfully = $this->item->save();

        if (!$wasSavedSuccessfully) {
            DB::rollBack();
            return;
        }

        DB::commit();
        $this->emitUp('refreshChildren', [$this->item->parent_id]);
        foreach ($movedItems as $movedItem) {
            $this->emit('sequenceChanged', $movedItem);
        }
    } catch ( \Throwable $ex ) {
        DB::rollBack();
        Log::error($ex->getMessage());
    }
}

class ArticleCategoryListItem extends CategoryListItem
{
    public function mount(CategoryModel $articleCategory = null)
    {
        $this->formComponent = "article-category-form";
        parent::mount($articleCategory);
    }
}

class CategoryForm extends Component
{
    public ?CategoryModel $category;
    public $categories;
    public bool $showForm = false;
    public bool $hasSlug = false;

    protected $rules = [
        'category.title' => 'required',
        'category.sequence_no' => 'required',
        /* The rule on parent_id is to prevent CannotBindToModelDataWithoutValidationRuleException */
        'category.parent_id' => '',
    ];

    public function render()
    {
        return view('livewire.category-form');
    }

    public function updated($propertyName)
    {
        $this->validateOnly($propertyName);
    }

    public function submit()
    {
        $oldParentId = $this->category->getRawOriginal('parent_id');
        $oldTitle = $this->category->getRawOriginal('title');

        if (empty($this->category->sequence_no) || $this->category->parent_id !== $oldParentId) {
            $modelClass = get_class($this->category);
            if (empty($this->category->parent_id)) {
                $currentMax = $modelClass::whereNull('parent_id')->max('sequence_no');
				if (empty($currentMax)) {
					$currentMax = 0;
				}
                $this->category->sequence_no = $currentMax + 1;
            } else {
                $parentCategory = $modelClass::find($this->category->parent_id);
                $this->category->sequence_no = $parentCategory->next_sequence_no;
            }
        }

        $this->validate();

        $is_new = empty($this->category->id);

        /* Ensure everything is done in a single transaction, so we can roll back if anything goes wrong */
        DB::beginTransaction();
		$wasSavedSuccessfully = $this->category->save();

        if (!$wasSavedSuccessfully) {
            DB::rollBack();
            session()->flash('failure', 'Failed to save category.');
            return;
        }

        DB::commit();
        session()->flash('success', 'Category successfully saved.');

        $modelClass = get_class($this->category);
        $this->categories = $modelClass::orderBy('set_start', 'asc')->get();

        if ($is_new) {
            /* If we added a new category, emit an event so its parent knows to re-render. */
            if ( !empty($this->category->parent_id) ) {
                $this->emitTo('tree-view-item', 'refreshChildren', [(int) $this->category->parent_id]);
            }
        } else {
            if ( $this->category->parent_id !== $oldParentId ) {
                /* If we changed parent, emit an event so the old and new parents know to re-render. */
                $this->emitTo('tree-view-item', 'parentChanged', [(int) $oldParentId, (int) $this->category->parent_id]);
            }
            if ( $this->category->title !== $oldTitle ) {
                /* If the title changed, emit an event so the item knows to re-render. */
                $this->emitTo('tree-view-item', 'titleChanged', $this->category->id);
            }
        }
        $this->emitUp('categoryFormSubmitCompleted', $this->category->id);
    }
}

class ArticleCategoryForm extends CategoryForm
{
    public function mount(ArticleCategory $articleCategory = null)
    {
        $this->category = $articleCategory;
        $this->categories = ArticleCategory::orderBy('global_sequence', 'asc')->get();
    }
}

abstract class CategoryModel extends HierarchicalModel
{
    /* Get the next available sequence_no for children of this category */
    public function getNextSequenceNoAttribute()
    {
        if ( count($this->children ) === 0 ) {
            return 1;
        }
        $currentMax = self::where('parent_id', $this->id)->max('sequence_no');
        return $currentMax + 1;
    }

    /* Get a string to indent the category in a list of options */
    public function getIndentAttribute()
    {
        return str_repeat('-', ($this->depth - 1) * 2);
    }
}

$this->maxSequenceNo = $modelClass::find($this->category->parent_id)->next_sequence_no - 1;