*/
public class ProtwordsItem extends DictionaryItem {
    private final String input;

    private String newInput;

    /**
     * Constructor for ProtwordsItem.
     * @param id the unique identifier for this item
     * @param input the protected word input
     */
    public ProtwordsItem(final long id, final String input) {
        this.id = id;

        getProtwordsFile(dictId).ifPresent(file -> {
            if (protwordsItem.getId() == 0) {
                file.insert(protwordsItem);
            } else {
                file.update(protwordsItem);
            }
        });
    }

    /**
     * Deletes a protected words item.
     * @param dictId the dictionary ID
     * @param protwordsItem the item to delete
     */

        // Create updater with a new item
        ProtwordsItem newItem = new ProtwordsItem(0, "testNew");
        ProtwordsFile.ProtwordsUpdater updater = protwordsFile.new ProtwordsUpdater(newItem);

        // Write an existing item (should pass through)
        ProtwordsItem existingItem = new ProtwordsItem(10, "existing");
        ProtwordsItem result = updater.write(existingItem);

        assertNotNull(result);

    }

    @Test
    public void test_equals() {
        // Test equals method
        ProtwordsItem item1 = new ProtwordsItem(1, "word");
        ProtwordsItem item2 = new ProtwordsItem(2, "word");
        ProtwordsItem item3 = new ProtwordsItem(1, "different");
        ProtwordsItem item4 = new ProtwordsItem(1, "word");

        // Same object
        assertTrue(item1.equals(item1));

    }

    @Override
    public synchronized OptionalEntity<ProtwordsItem> get(final long id) {
        if (protwordsItemList == null) {
            reload(null);
        }

        for (final ProtwordsItem ProtwordsItem : protwordsItemList) {
            if (id == ProtwordsItem.getId()) {
                return OptionalEntity.of(ProtwordsItem);
            }
        }
        return OptionalEntity.empty();
    }

        return asJson(new ApiResult.ApiConfigsResponse<EditBody>().settings(protwordsService.getProtwordsList(body.dictId, pager)
                .stream()
                .map(protwordsItem -> createEditBody(protwordsItem, dictId))
                .collect(Collectors.toList())).status(ApiResult.Status.OK).result());
    }

    /**
     * Retrieve a single protected words entry by ID for the specified dictionary.
     *

    //                                                                        ============

    private static OptionalEntity<ProtwordsItem> getEntity(final CreateForm form) {
        switch (form.crudMode) {
        case CrudMode.CREATE:
            final ProtwordsItem entity = new ProtwordsItem(0, StringUtil.EMPTY);
            return OptionalEntity.of(entity);
        case CrudMode.EDIT:
            if (form instanceof EditForm) {

        return asJson(new ApiResult.ApiConfigsResponse<EditBody>().settings(kuromojiService.getKuromojiList(body.dictId, pager)
                .stream()
                .map(protwordsItem -> createEditBody(protwordsItem, dictId))
                .collect(Collectors.toList())).status(ApiResult.Status.OK).result());
    }

    /**
     * Retrieves a specific Kuromoji dictionary item by ID.
     *

                new ApiResult.ApiConfigsResponse<EditBody>().settings(stemmerOverrideService.getStemmerOverrideList(body.dictId, pager)
                        .stream()
                        .map(protwordsItem -> createEditBody(protwordsItem, dictId))
                        .collect(Collectors.toList())).status(ApiResult.Status.OK).result());
    }

    /**
     * Retrieves a specific stemmer override dictionary item by ID.
     *

        return asJson(new ApiResult.ApiConfigsResponse<EditBody>().settings(synonymService.getSynonymList(body.dictId, pager)
                .stream()
                .map(protwordsItem -> createEditBody(protwordsItem, dictId))
                .collect(Collectors.toList())).status(ApiResult.Status.OK).result());
    }

    /**
     * Retrieves a specific synonym dictionary item by ID.
     *